@e22m4u/js-repository 0.1.4 → 0.1.6

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

@@ -7,40 +7,36 @@ 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 +48,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 +67,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 +86,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 +106,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 +125,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 +139,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,1789 +160,1836 @@ 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.',
         );
       });
     });
 
-    describe('DataType.ANY', function () {
-      describe('ShortPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ANY,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
-          });
-        });
-
-        it('does not throw an error if a null given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ANY,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+    describe('validate by property type', function () {
+      describe('DataType.ANY', function () {
+        describe('ShortPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ANY,
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-        });
 
-        it('does not throw an error if a string given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ANY,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+          it('does not throw an error if a null given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ANY,
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-        });
 
-        it('does not throw an error if a number given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ANY,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+          it('does not throw an error if a string given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ANY,
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 'bar',
+            });
           });
-        });
 
-        it('does not throw an error if true given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ANY,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+          it('does not throw an error if a number given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ANY,
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 10,
+            });
           });
-        });
 
-        it('does not throw an error if false given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ANY,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+          it('does not throw an error if true given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ANY,
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: true,
+            });
           });
-        });
 
-        it('does not throw an error if an array given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ANY,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+          it('does not throw an error if false given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ANY,
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: false,
+            });
           });
-        });
 
-        it('does not throw an error if an object given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ANY,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+          it('does not throw an error if an array given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ANY,
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: [],
+            });
           });
-        });
-      });
 
-      describe('FullPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ANY,
+          it('does not throw an error if an object given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ANY,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: {},
+            });
           });
         });
 
-        it('does not throw an error if a null given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ANY,
+        describe('FullPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-        });
 
-        it('does not throw an error if a string given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ANY,
+          it('does not throw an error if a null given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-        });
 
-        it('does not throw an error if a number given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ANY,
+          it('does not throw an error if a string given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 'bar',
+            });
           });
-        });
 
-        it('does not throw an error if true given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ANY,
+          it('does not throw an error if a number given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 10,
+            });
           });
-        });
 
-        it('does not throw an error if false given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ANY,
+          it('does not throw an error if true given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: true,
+            });
           });
-        });
 
-        it('does not throw an error if an array given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ANY,
+          it('does not throw an error if false given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: false,
+            });
           });
-        });
 
-        it('does not throw an error if an object given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ANY,
+          it('does not throw an error if an array given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: {},
-          });
-        });
-      });
-    });
-
-    describe('DataType.STRING', function () {
-      describe('ShortPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.STRING,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
-          });
-        });
-
-        it('does not throw an error if a null given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.STRING,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
-          });
-        });
-
-        it('does not throw an error if a string given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.STRING,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
-          });
-        });
-
-        it('throws an error if a number given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.STRING,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
-          });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a String, but Number given.',
-          );
-        });
-
-        it('throws an error if true given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.STRING,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: true,
-          });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a String, but Boolean given.',
-          );
-        });
-
-        it('throws an error if false given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.STRING,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: false,
-          });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a String, but Boolean given.',
-          );
-        });
-
-        it('throws an error if an array given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.STRING,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: [],
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a String, but Array given.',
-          );
-        });
 
-        it('throws an error if an object given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.STRING,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+          it('does not throw an error if an object given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: {},
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a String, but Object given.',
-          );
         });
       });
 
-      describe('FullPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.STRING,
+      describe('DataType.STRING', function () {
+        describe('ShortPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.STRING,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-        });
 
-        it('does not throw an error if a null given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.STRING,
+          it('does not throw an error if a null given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.STRING,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-        });
 
-        it('does not throw an error if a string given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.STRING,
+          it('does not throw an error if a string given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.STRING,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 'bar',
+            });
           });
-        });
 
-        it('throws an error if a number given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.STRING,
+          it('throws an error if a number given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.STRING,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a String, but Number given.',
-          );
-        });
 
-        it('throws an error if true given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.STRING,
+          it('throws an error if true given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.STRING,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a String, but Boolean given.',
-          );
-        });
 
-        it('throws an error if false given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.STRING,
+          it('throws an error if false given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.STRING,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a String, but Boolean given.',
-          );
-        });
 
-        it('throws an error if an array given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.STRING,
+          it('throws an error if an array given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.STRING,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a String, but Array given.',
-          );
-        });
 
-        it('throws an error if an object given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.STRING,
+          it('throws an error if an object given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.STRING,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a String, but Object given.',
-          );
         });
-      });
-    });
 
-    describe('DataType.NUMBER', function () {
-      describe('ShortPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.NUMBER,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
+        describe('FullPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.STRING,
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-        });
 
-        it('does not throw an error if a null given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.NUMBER,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+          it('does not throw an error if a null given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.STRING,
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-        });
 
-        it('throws an error if a string given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.NUMBER,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+          it('does not throw an error if a string given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.STRING,
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 'bar',
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Number, but String given.',
-          );
-        });
 
-        it('does not throw an error if a number given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.NUMBER,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+          it('throws an error if a number given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.STRING,
+                },
+              },
+            });
+            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 () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.NUMBER,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+          it('throws an error if true given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.STRING,
+                },
+              },
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Number, but Boolean given.',
-          );
-        });
 
-        it('throws an error if false given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.NUMBER,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+          it('throws an error if false given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.STRING,
+                },
+              },
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Number, but Boolean given.',
-          );
-        });
 
-        it('throws an error if an array given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.NUMBER,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+          it('throws an error if an array given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.STRING,
+                },
+              },
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Number, but Array given.',
-          );
-        });
 
-        it('throws an error if an object given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.NUMBER,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+          it('throws an error if an object given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.STRING,
+                },
+              },
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Number, but Object given.',
-          );
         });
       });
 
-      describe('FullPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.NUMBER,
+      describe('DataType.NUMBER', function () {
+        describe('ShortPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.NUMBER,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-        });
 
-        it('does not throw an error if a null given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.NUMBER,
+          it('does not throw an error if a null given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.NUMBER,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-        });
 
-        it('throws an error if a string given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.NUMBER,
+          it('throws an error if a string given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.NUMBER,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Number, but String given.',
-          );
-        });
 
-        it('does not throw an error if a number given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.NUMBER,
+          it('does not throw an error if a number given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.NUMBER,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 10,
+            });
           });
-        });
 
-        it('throws an error if true given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.NUMBER,
+          it('throws an error if true given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.NUMBER,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Number, but Boolean given.',
-          );
-        });
 
-        it('throws an error if false given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.NUMBER,
+          it('throws an error if false given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.NUMBER,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Number, but Boolean given.',
-          );
-        });
 
-        it('throws an error if an array given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.NUMBER,
+          it('throws an error if an array given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.NUMBER,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Number, but Array given.',
-          );
-        });
 
-        it('throws an error if an object given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.NUMBER,
+          it('throws an error if an object given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.NUMBER,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Number, but Object given.',
-          );
         });
-      });
-    });
 
-    describe('DataType.BOOLEAN', function () {
-      describe('ShortPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.BOOLEAN,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
+        describe('FullPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-        });
 
-        it('does not throw an error if a null given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.BOOLEAN,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+          it('does not throw an error if a null given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-        });
 
-        it('throws an error if a string given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.BOOLEAN,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+          it('throws an error if a string given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
+              },
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Boolean, but String given.',
-          );
-        });
 
-        it('throws an error if a number given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.BOOLEAN,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+          it('does not throw an error if a number given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: 10,
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Boolean, but Number given.',
-          );
-        });
 
-        it('does not throw an error if true given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.BOOLEAN,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+          it('throws an error if true given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
+              },
+            });
+            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('does not throw an error if false given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.BOOLEAN,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+          it('throws an error if false given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
+              },
+            });
+            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 () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.BOOLEAN,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+          it('throws an error if an array given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
+              },
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Boolean, but Array given.',
-          );
-        });
 
-        it('throws an error if an object given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.BOOLEAN,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+          it('throws an error if an object given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
+              },
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Boolean, but Object given.',
-          );
         });
       });
 
-      describe('FullPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.BOOLEAN,
+      describe('DataType.BOOLEAN', function () {
+        describe('ShortPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.BOOLEAN,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-        });
 
-        it('does not throw an error if a null given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.BOOLEAN,
+          it('does not throw an error if a null given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.BOOLEAN,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-        });
 
-        it('throws an error if a string given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.BOOLEAN,
+          it('throws an error if a string given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.BOOLEAN,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Boolean, but String given.',
-          );
-        });
 
-        it('throws an error if a number given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.BOOLEAN,
+          it('throws an error if a number given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.BOOLEAN,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Boolean, but Number given.',
-          );
-        });
 
-        it('does not throw an error if true given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.BOOLEAN,
+          it('does not throw an error if true given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.BOOLEAN,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: true,
+            });
           });
-        });
 
-        it('does not throw an error if false given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.BOOLEAN,
-              },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+          it('does not throw an error if false given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.BOOLEAN,
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: false,
+            });
           });
-        });
 
-        it('throws an error if an array given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.BOOLEAN,
+          it('throws an error if an array given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.BOOLEAN,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Boolean, but Array given.',
-          );
-        });
 
-        it('throws an error if an object given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.BOOLEAN,
+          it('throws an error if an object given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.BOOLEAN,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'a Boolean, but Object given.',
-          );
         });
-      });
-    });
 
-    describe('DataType.ARRAY', function () {
-      describe('ShortPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ARRAY,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
+        describe('FullPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-        });
 
-        it('does not throw an error if a null given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ARRAY,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+          it('does not throw an error if a null given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-        });
 
-        it('throws an error if a string given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ARRAY,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+          it('throws an error if a string given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
+              },
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Array, but String given.',
-          );
-        });
 
-        it('throws an error if a number given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ARRAY,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+          it('throws an error if a number given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
+              },
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Array, but Number given.',
-          );
-        });
 
-        it('throws an error if true given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ARRAY,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+          it('does not throw an error if true given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: true,
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Array, but Boolean given.',
-          );
-        });
 
-        it('throws an error if false given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ARRAY,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+          it('does not throw an error if false given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: false,
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Array, but Boolean given.',
-          );
-        });
 
-        it('does not throw an error if an array given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ARRAY,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+          it('throws an error if an array given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
+              },
+            });
+            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 () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.ARRAY,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+          it('throws an error if an object given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
+              },
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Array, but Object given.',
-          );
         });
       });
 
-      describe('FullPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ARRAY,
+      describe('DataType.ARRAY', function () {
+        describe('ShortPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ARRAY,
               },
-            },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
+
+          it('does not throw an error if a null given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ARRAY,
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-        });
 
-        it('does not throw an error if a null given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ARRAY,
+          it('throws an error if a string given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ARRAY,
               },
-            },
+            });
+            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.',
+            );
           });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+
+          it('throws an error if a number given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ARRAY,
+              },
+            });
+            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 a string given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ARRAY,
+          it('throws an error if true given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ARRAY,
               },
-            },
+            });
+            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.',
+            );
           });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+
+          it('throws an error if false given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ARRAY,
+              },
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Array, but String given.',
-          );
-        });
 
-        it('throws an error if a number given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ARRAY,
+          it('does not throw an error if an array given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ARRAY,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: [],
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Array, but Number given.',
-          );
-        });
 
-        it('throws an error if true given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ARRAY,
+          it('throws an error if an object given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.ARRAY,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Array, but Boolean given.',
-          );
         });
 
-        it('throws an error if false given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ARRAY,
+        describe('FullPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ARRAY,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Array, but Boolean given.',
-          );
-        });
 
-        it('does not throw an error if an array given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ARRAY,
+          it('does not throw an error if a null given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ARRAY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-        });
 
-        it('throws an error if an object given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.ARRAY,
+          it('throws an error if a string given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ARRAY,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Array, but Object given.',
-          );
-        });
 
-        describe('the "model" option', function () {
-          it('throws an error when the given object element has an invalid model', async function () {
+          it('throws an error if a number given', function () {
             const S = new Schema();
             S.defineModel({
-              name: 'modelA',
+              name: 'model',
+              datasource: 'datasource',
               properties: {
-                foo: DataType.STRING,
+                foo: {
+                  type: DataType.ARRAY,
+                },
               },
             });
+            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', function () {
+            const S = new Schema();
             S.defineModel({
-              name: 'modelB',
+              name: 'model',
               datasource: 'datasource',
               properties: {
-                bar: {
+                foo: {
                   type: DataType.ARRAY,
-                  itemType: DataType.OBJECT,
-                  model: 'modelA',
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate(
-              'modelB',
-              {
-                bar: [{foo: 10}],
-              },
-            );
-            await expect(promise).to.be.rejectedWith(
-              'The property "foo" of the model "modelA" must have ' +
-                'a String, but Number given.',
+            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('does not throw an error when the given object element has a valid model', async function () {
+          it('throws an error if false given', function () {
             const S = new Schema();
             S.defineModel({
-              name: 'modelA',
+              name: 'model',
+              datasource: 'datasource',
               properties: {
-                foo: DataType.STRING,
+                foo: {
+                  type: DataType.ARRAY,
+                },
               },
             });
+            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', function () {
+            const S = new Schema();
             S.defineModel({
-              name: 'modelB',
+              name: 'model',
               datasource: 'datasource',
               properties: {
-                bar: {
+                foo: {
                   type: DataType.ARRAY,
-                  itemType: DataType.OBJECT,
-                  model: 'modelA',
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('modelB', {
-              bar: [{foo: '10'}],
+            S.getService(ModelDataValidator).validate('model', {
+              foo: [],
             });
           });
-        });
-      });
-    });
-
-    describe('DataType.OBJECT', function () {
-      describe('ShortPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.OBJECT,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
-          });
-        });
 
-        it('does not throw an error if a null given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.OBJECT,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+          it('throws an error if an object given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ARRAY,
+                },
+              },
+            });
+            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.',
+            );
           });
-        });
 
-        it('throws an error if a string given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.OBJECT,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
-          });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Object, but String given.',
-          );
-        });
+          describe('the "model" option', function () {
+            it('throws an error when the given object element has an invalid model', function () {
+              const S = new Schema();
+              S.defineModel({
+                name: 'modelA',
+                properties: {
+                  foo: DataType.STRING,
+                },
+              });
+              S.defineModel({
+                name: 'modelB',
+                datasource: 'datasource',
+                properties: {
+                  bar: {
+                    type: DataType.ARRAY,
+                    itemType: DataType.OBJECT,
+                    model: 'modelA',
+                  },
+                },
+              });
+              const throwable = () =>
+                S.getService(ModelDataValidator).validate('modelB', {
+                  bar: [{foo: 10}],
+                });
+              expect(throwable).to.throw(
+                'The property "foo" of the model "modelA" must have ' +
+                  'a String, but Number given.',
+              );
+            });
 
-        it('throws an error if a number given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.OBJECT,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+            it('does not throw an error when the given object element has a valid model', function () {
+              const S = new Schema();
+              S.defineModel({
+                name: 'modelA',
+                properties: {
+                  foo: DataType.STRING,
+                },
+              });
+              S.defineModel({
+                name: 'modelB',
+                datasource: 'datasource',
+                properties: {
+                  bar: {
+                    type: DataType.ARRAY,
+                    itemType: DataType.OBJECT,
+                    model: 'modelA',
+                  },
+                },
+              });
+              S.getService(ModelDataValidator).validate('modelB', {
+                bar: [{foo: '10'}],
+              });
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Object, but Number given.',
-          );
         });
+      });
 
-        it('throws an error if true given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.OBJECT,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+      describe('DataType.OBJECT', function () {
+        describe('ShortPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.OBJECT,
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Object, but Boolean given.',
-          );
-        });
 
-        it('throws an error if false given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.OBJECT,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+          it('does not throw an error if a null given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.OBJECT,
+              },
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Object, but Boolean given.',
-          );
-        });
 
-        it('throws an error if an array given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.OBJECT,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+          it('throws an error if a string given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.OBJECT,
+              },
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Object, but Array given.',
-          );
-        });
 
-        it('does not throw an error if an object given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: DataType.OBJECT,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+          it('throws an error if a number given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.OBJECT,
+              },
+            });
+            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.',
+            );
           });
-        });
-      });
 
-      describe('FullPropertyDefinition', function () {
-        it('does not throw an error if an undefined given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.OBJECT,
+          it('throws an error if true given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.OBJECT,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
+            });
+            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('does not throw an error if a null given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.OBJECT,
+          it('throws an error if false given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.OBJECT,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+            });
+            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 a string given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.OBJECT,
+          it('throws an error if an array given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.OBJECT,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Object, but String given.',
-          );
-        });
 
-        it('throws an error if a number given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.OBJECT,
+          it('does not throw an error if an object given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.OBJECT,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: {},
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Object, but Number given.',
-          );
         });
 
-        it('throws an error if true given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.OBJECT,
+        describe('FullPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.OBJECT,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Object, but Boolean given.',
-          );
-        });
 
-        it('throws an error if false given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.OBJECT,
+          it('does not throw an error if a null given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.OBJECT,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+            });
+            S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Object, but Boolean given.',
-          );
-        });
 
-        it('throws an error if an array given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.OBJECT,
+          it('throws an error if a string given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.OBJECT,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+            });
+            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.',
+            );
           });
-          await expect(promise).to.be.rejectedWith(
-            'The property "foo" of the model "model" must have ' +
-              'an Object, but Array given.',
-          );
-        });
 
-        it('does not throw an error if an object given', async function () {
-          const S = new Schema();
-          S.defineModel({
-            name: 'model',
-            datasource: 'datasource',
-            properties: {
-              foo: {
-                type: DataType.OBJECT,
+          it('throws an error if a number given', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.OBJECT,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+            });
+            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.',
+            );
           });
-        });
 
-        describe('the "model" option', function () {
-          it('throws an error when the given object has an invalid model', async function () {
+          it('throws an error if true given', function () {
             const S = new Schema();
             S.defineModel({
-              name: 'modelA',
+              name: 'model',
+              datasource: 'datasource',
               properties: {
-                foo: DataType.STRING,
+                foo: {
+                  type: DataType.OBJECT,
+                },
               },
             });
+            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', function () {
+            const S = new Schema();
             S.defineModel({
-              name: 'modelB',
+              name: 'model',
               datasource: 'datasource',
               properties: {
-                bar: {
+                foo: {
                   type: DataType.OBJECT,
-                  model: 'modelA',
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator).validate(
-              'modelB',
-              {
-                bar: {foo: 10},
-              },
-            );
-            await expect(promise).to.be.rejectedWith(
-              'The property "foo" of the model "modelA" must have ' +
-                'a String, but Number given.',
+            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('does not throw an error when the given object has a valid model', async function () {
+          it('throws an error if an array given', function () {
             const S = new Schema();
             S.defineModel({
-              name: 'modelA',
+              name: 'model',
+              datasource: 'datasource',
               properties: {
-                foo: DataType.STRING,
+                foo: {
+                  type: DataType.OBJECT,
+                },
               },
             });
+            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', function () {
+            const S = new Schema();
             S.defineModel({
-              name: 'modelB',
+              name: 'model',
               datasource: 'datasource',
               properties: {
-                bar: {
+                foo: {
                   type: DataType.OBJECT,
-                  model: 'modelA',
                 },
               },
             });
-            await S.getService(ModelDataValidator).validate('modelB', {
-              bar: {foo: '10'},
+            S.getService(ModelDataValidator).validate('model', {
+              foo: {},
+            });
+          });
+
+          describe('the "model" option', function () {
+            it('throws an error when the given object has an invalid model', function () {
+              const S = new Schema();
+              S.defineModel({
+                name: 'modelA',
+                properties: {
+                  foo: DataType.STRING,
+                },
+              });
+              S.defineModel({
+                name: 'modelB',
+                datasource: 'datasource',
+                properties: {
+                  bar: {
+                    type: DataType.OBJECT,
+                    model: 'modelA',
+                  },
+                },
+              });
+              const throwable = () =>
+                S.getService(ModelDataValidator).validate('modelB', {
+                  bar: {foo: 10},
+                });
+              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', function () {
+              const S = new Schema();
+              S.defineModel({
+                name: 'modelA',
+                properties: {
+                  foo: DataType.STRING,
+                },
+              });
+              S.defineModel({
+                name: 'modelB',
+                datasource: 'datasource',
+                properties: {
+                  bar: {
+                    type: DataType.OBJECT,
+                    model: 'modelA',
+                  },
+                },
+              });
+              S.getService(ModelDataValidator).validate('modelB', {
+                bar: {foo: '10'},
+              });
             });
           });
         });
@@ -1956,10 +1998,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('do not validate null and undefined values', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
+            'myValidator',
             () => false,
           );
           S.defineModel({
@@ -1967,52 +2009,53 @@ describe('ModelDataValidator', function () {
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: 'validator',
+                validate: 'myValidator',
               },
               bar: {
                 type: DataType.ANY,
-                validate: 'validator',
+                validate: 'myValidator',
               },
               baz: {
                 type: DataType.ANY,
-                validate: 'validator',
+                validate: 'myValidator',
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: null,
             bar: undefined,
           });
         });
 
-        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({
@@ -2020,19 +2063,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({
@@ -2040,20 +2083,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({
@@ -2061,124 +2109,93 @@ 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);
-        });
-
-        it('passes arguments to the validator', async function () {
+          testFn('str');
+          testFn('');
+          testFn(10);
+          testFn(0);
+          testFn(false);
+          testFn(undefined);
+          testFn(null);
+          testFn({});
+          testFn([]);
+          testFn(() => undefined);
+        });
+
+        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);
-            });
-          };
-          const S = new Schema();
-          S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
-            validator,
-          );
-          S.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: 'validator',
-              },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          await expect(promise).to.be.rejectedWith(error);
-        });
       });
 
       describe('the option "validate" with an array value', function () {
-        it('does nothing for an empty array validators', async function () {
+        it('does nothing for an empty array validators', function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -2189,15 +2206,15 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: 'test',
           });
         });
 
-        it('do not validate null and undefined values', async function () {
+        it('do not validate null and undefined values', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
+            'myValidator',
             () => false,
           );
           S.defineModel({
@@ -2205,221 +2222,194 @@ describe('ModelDataValidator', function () {
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: ['validator'],
+                validate: ['myValidator'],
               },
               bar: {
                 type: DataType.ANY,
-                validate: ['validator'],
+                validate: ['myValidator'],
               },
               baz: {
                 type: DataType.ANY,
-                validate: ['validator'],
+                validate: ['myValidator'],
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: null,
             bar: undefined,
           });
         });
 
-        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);
-        });
-
-        it('passes arguments to the validator', async function () {
+          testFn('str');
+          testFn('');
+          testFn(10);
+          testFn(0);
+          testFn(false);
+          testFn(undefined);
+          testFn(null);
+          testFn({});
+          testFn([]);
+          testFn(() => undefined);
+        });
+
+        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);
-          S.defineModel({
-            name: 'model',
-            properties: {
-              foo: {
-                type: DataType.ANY,
-                validate: ['validator1', 'validator2'],
-              },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          expect(invocation).to.be.eql(['validator1', 'validator2']);
-        });
-
-        it('waits rejection from one of async validators', async function () {
-          const error1 = new Error('Occurs after 15 ms');
-          const error2 = new Error('Occurs after 5 ms');
-          const validator1 = () =>
-            new Promise((res, rej) => {
-              setTimeout(() => rej(error1), 15);
-            });
-          const validator2 = () =>
-            new Promise((res, rej) => {
-              setTimeout(() => rej(error2), 5);
-            });
-          const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator1', validator1)
-            .addValidator('validator2', validator2);
+            .addValidator('myValidator1', validator1)
+            .addValidator('myValidator2', validator2);
           S.defineModel({
             name: 'model',
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: ['validator1', 'validator2'],
+                validate: ['myValidator1', 'myValidator2'],
               },
             },
           });
-          const promise = S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: 'test',
           });
-          await expect(promise).to.be.rejectedWith(error2);
+          expect(invocation).to.be.eql(['myValidator1', 'myValidator2']);
         });
       });
 
       describe('the option "validate" with an object value', function () {
-        it('does nothing for an empty validators object', async function () {
+        it('does nothing for an empty validators object', function () {
           const S = new Schema();
           S.defineModel({
             name: 'model',
@@ -2430,15 +2420,15 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: 'test',
           });
         });
 
-        it('do not validate null and undefined values', async function () {
+        it('do not validate null and undefined values', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
-            'validator',
+            'myValidator',
             () => false,
           );
           S.defineModel({
@@ -2447,37 +2437,37 @@ describe('ModelDataValidator', function () {
               foo: {
                 type: DataType.ANY,
                 validate: {
-                  validator: true,
+                  myValidator: true,
                 },
               },
               bar: {
                 type: DataType.ANY,
                 validate: {
-                  validator: true,
+                  myValidator: true,
                 },
               },
               baz: {
                 type: DataType.ANY,
                 validate: {
-                  validator: true,
+                  myValidator: true,
                 },
               },
             },
           });
-          await S.getService(ModelDataValidator).validate('model', {
+          S.getService(ModelDataValidator).validate('model', {
             foo: null,
             bar: undefined,
           });
         });
 
-        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',
@@ -2485,129 +2475,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);
-        });
-
-        it('passes arguments to the validator', async function () {
+          testFn('str');
+          testFn('');
+          testFn(10);
+          testFn(0);
+          testFn(false);
+          testFn(undefined);
+          testFn(null);
+          testFn({});
+          testFn([]);
+          testFn(() => undefined);
+        });
+
+        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',
@@ -2615,7 +2602,7 @@ describe('ModelDataValidator', function () {
               foo: {
                 type: DataType.ANY,
                 validate: {
-                  validator: {
+                  myValidator: {
                     option1: 'value1',
                     option2: 'value2',
                   },
@@ -2623,54 +2610,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',
@@ -2678,49 +2665,16 @@ 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,
-                },
-              },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'test',
-          });
-          await expect(promise).to.be.rejectedWith(error2);
-        });
       });
     });
   });