@e22m4u/js-repository 0.1.3 → 0.1.5

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

@@ -174,1780 +174,1782 @@ describe('ModelDataValidator', function () {
       });
     });
 
-    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,
+    describe('validate by property type', function () {
+      describe('DataType.ANY', function () {
+        describe('ShortPropertyDefinition', function () {
+          it('does not throw an error if an undefined given', async function () {
+            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,
+          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,
+            });
           });
-        });
 
-        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 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 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 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 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 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 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 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 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 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 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 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: {},
+            });
           });
         });
-      });
 
-      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,
+        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,
+                },
               },
-            },
-          });
-          await 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', 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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+            });
+            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: {
-                type: DataType.ANY,
+          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,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+            });
+            await S.getService(ModelDataValidator).validate('model', {
+              foo: 'bar',
+            });
           });
-        });
 
-        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 number given', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+            });
+            await S.getService(ModelDataValidator).validate('model', {
+              foo: 10,
+            });
           });
-        });
 
-        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 true given', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+            });
+            await 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.ANY,
+          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,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+            });
+            await S.getService(ModelDataValidator).validate('model', {
+              foo: false,
+            });
           });
-        });
 
-        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 an array given', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+            });
+            await S.getService(ModelDataValidator).validate('model', {
+              foo: [],
+            });
           });
-        });
 
-        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 object given', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ANY,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+            });
+            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,
+      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 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('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('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,
+          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',
+            });
           });
-          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,
+          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.',
+            );
           });
-          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,
+          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.',
+            );
           });
-          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: [],
+          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.',
+            );
           });
-          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('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: [],
+            });
+            await expect(promise).to.be.rejectedWith(
+              '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 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,
+          it('throws an error if an object 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,
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: {},
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a String, but Object given.',
+            );
           });
         });
 
-        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,
+        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,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+            });
+            await 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.STRING,
+          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,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+            });
+            await S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-        });
 
-        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('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,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+            });
+            await S.getService(ModelDataValidator).validate('model', {
+              foo: 'bar',
+            });
           });
-          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 a number given', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.STRING,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+            });
+            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.',
+            );
           });
-          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 true given', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.STRING,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+            });
+            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.',
+            );
           });
-          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 false given', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.STRING,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+            });
+            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.',
+            );
           });
-          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 array given', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.STRING,
+                },
               },
-            },
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: [],
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a String, but Array given.',
+            );
           });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+
+          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,
+                },
+              },
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: {},
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a String, but Object given.',
+            );
           });
-          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('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,
+            });
           });
-        });
 
-        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', 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('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('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',
+            });
+            await expect(promise).to.be.rejectedWith(
+              '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: DataType.NUMBER,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+          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 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', 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,
+            });
+            await expect(promise).to.be.rejectedWith(
+              '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: DataType.NUMBER,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+          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,
+            });
+            await expect(promise).to.be.rejectedWith(
+              '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: DataType.NUMBER,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+          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: [],
+            });
+            await expect(promise).to.be.rejectedWith(
+              '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: DataType.NUMBER,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+          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: {},
+            });
+            await expect(promise).to.be.rejectedWith(
+              '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('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('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,
+                },
               },
-            },
-          });
-          await 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', 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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+            });
+            await 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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: 'bar',
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a Number, but String given.',
+            );
           });
-          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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+            });
+            await 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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: true,
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a Number, but Boolean given.',
+            );
           });
-          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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: false,
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: false,
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a Number, but Boolean given.',
+            );
           });
-          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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: [],
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a Number, but Array given.',
+            );
           });
-          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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.NUMBER,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: {},
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a Number, but Object given.',
+            );
           });
-          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('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,
+            });
           });
-        });
 
-        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', 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('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', 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',
+            });
+            await expect(promise).to.be.rejectedWith(
+              '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: DataType.BOOLEAN,
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+          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,
+            });
+            await expect(promise).to.be.rejectedWith(
+              '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: DataType.BOOLEAN,
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+          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('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('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 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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.BOOLEAN,
+              },
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: [],
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a Boolean, but Array given.',
+            );
           });
-          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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.BOOLEAN,
+              },
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: {},
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a Boolean, but Object given.',
+            );
           });
-          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('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,
+                },
               },
-            },
-          });
-          await 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', 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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+            });
+            await 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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 'bar',
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: 'bar',
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a Boolean, but String given.',
+            );
           });
-          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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: 10,
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: 10,
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a Boolean, but Number given.',
+            );
           });
-          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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+            });
+            await 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,
+          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,
+            });
+            await 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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: [],
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a Boolean, but Array given.',
+            );
           });
-          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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.BOOLEAN,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: {},
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'a Boolean, but Object given.',
+            );
           });
-          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,
-          });
-        });
-
-        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('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',
-          });
-          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,
-          });
-          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,
-          });
-          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,
-          });
-          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: [],
+      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,
+            });
           });
-        });
 
-        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('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,
+            });
           });
-          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,
+          it('throws an error if a string 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,
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: 'bar',
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Array, but String given.',
+            );
           });
-        });
 
-        it('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 number 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,
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: 10,
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Array, but Number given.',
+            );
           });
-        });
 
-        it('throws an error if 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', 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',
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: true,
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Array, but Boolean given.',
+            );
           });
-          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('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: 10,
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: false,
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Array, but Boolean given.',
+            );
           });
-          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('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,
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: true,
+            });
+            await S.getService(ModelDataValidator).validate('model', {
+              foo: [],
+            });
           });
-          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,
+          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: false,
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: {},
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Array, but Object given.',
+            );
           });
-          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,
+        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,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: [],
+            });
+            await S.getService(ModelDataValidator).validate('model', {
+              foo: undefined,
+            });
           });
-        });
 
-        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('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,
+                },
               },
-            },
-          });
-          const promise = S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+            });
+            await S.getService(ModelDataValidator).validate('model', {
+              foo: null,
+            });
           });
-          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 string given', async function () {
             const S = new Schema();
             S.defineModel({
-              name: 'modelA',
+              name: 'model',
+              datasource: 'datasource',
               properties: {
-                foo: DataType.STRING,
+                foo: {
+                  type: DataType.ARRAY,
+                },
               },
             });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: 'bar',
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Array, but String given.',
+            );
+          });
+
+          it('throws an error if a number given', async 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}],
-              },
-            );
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: 10,
+            });
             await expect(promise).to.be.rejectedWith(
-              'The property "foo" of the model "modelA" must have ' +
-                'a String, but Number given.',
+              'The property "foo" of the model "model" must have ' +
+                'an Array, but Number given.',
             );
           });
 
-          it('does not throw an error when the given object element has a valid model', async function () {
+          it('throws an error if true given', async function () {
             const S = new Schema();
             S.defineModel({
-              name: 'modelA',
+              name: 'model',
+              datasource: 'datasource',
               properties: {
-                foo: DataType.STRING,
+                foo: {
+                  type: DataType.ARRAY,
+                },
               },
             });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: true,
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Array, but Boolean given.',
+            );
+          });
+
+          it('throws an error if false given', async 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'}],
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: false,
             });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Array, but Boolean given.',
+            );
           });
-        });
-      });
-    });
 
-    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 an array given', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.ARRAY,
+                },
+              },
+            });
+            await 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: DataType.OBJECT,
-            },
-          });
-          await 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,
+                },
+              },
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: {},
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Array, but Object given.',
+            );
           });
-        });
 
-        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', async 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 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.',
+              );
+            });
 
-        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', async 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',
+                  },
+                },
+              });
+              await 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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.OBJECT,
+              },
+            });
+            await 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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.OBJECT,
+              },
+            });
+            await 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', 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.',
+            );
           });
-          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', 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,
+            });
+            await expect(promise).to.be.rejectedWith(
+              '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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.OBJECT,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: undefined,
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: true,
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Object, but Boolean given.',
+            );
           });
-        });
 
-        it('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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: DataType.OBJECT,
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: null,
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: false,
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Object, but Boolean given.',
+            );
           });
-        });
 
-        it('throws an error if 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', 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',
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: [],
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Object, but Array given.',
+            );
           });
-          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', 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,
+            });
+            await 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', async 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,
+            });
+            await 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', async 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,
+            });
+            await 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', async 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 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.',
+            );
           });
-          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', async function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'model',
+              datasource: 'datasource',
+              properties: {
+                foo: {
+                  type: DataType.OBJECT,
+                },
               },
-            },
-          });
-          await S.getService(ModelDataValidator).validate('model', {
-            foo: {},
+            });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: 10,
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Object, but Number given.',
+            );
           });
-        });
 
-        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', async function () {
             const S = new Schema();
             S.defineModel({
-              name: 'modelA',
+              name: 'model',
+              datasource: 'datasource',
               properties: {
-                foo: DataType.STRING,
+                foo: {
+                  type: DataType.OBJECT,
+                },
               },
             });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: true,
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Object, but Boolean given.',
+            );
+          });
+
+          it('throws an error if false given', async 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},
-              },
-            );
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: false,
+            });
             await expect(promise).to.be.rejectedWith(
-              'The property "foo" of the model "modelA" must have ' +
-                'a String, but Number given.',
+              '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', async function () {
             const S = new Schema();
             S.defineModel({
-              name: 'modelA',
+              name: 'model',
+              datasource: 'datasource',
               properties: {
-                foo: DataType.STRING,
+                foo: {
+                  type: DataType.OBJECT,
+                },
               },
             });
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: [],
+            });
+            await expect(promise).to.be.rejectedWith(
+              'The property "foo" of the model "model" must have ' +
+                'an Object, but Array given.',
+            );
+          });
+
+          it('does not throw an error if an object given', async 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'},
+            await S.getService(ModelDataValidator).validate('model', {
+              foo: {},
+            });
+          });
+
+          describe('the "model" option', function () {
+            it('throws an error when the given object has an invalid model', async function () {
+              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 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.',
+              );
+            });
+
+            it('does not throw an error when the given object has a valid model', async 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',
+                  },
+                },
+              });
+              await S.getService(ModelDataValidator).validate('modelB', {
+                bar: {foo: '10'},
+              });
             });
           });
         });
@@ -1958,8 +1960,10 @@ describe('ModelDataValidator', function () {
       describe('the option "validate" with the string value', function () {
         it('do not validate null and undefined values', async function () {
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', () => false);
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            () => false,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -1986,10 +1990,12 @@ describe('ModelDataValidator', function () {
         it('throws an error from the validator', async function () {
           const validator = function () {
             throw Error('My error');
-          }
+          };
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', validator);
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            validator,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2007,8 +2013,10 @@ describe('ModelDataValidator', function () {
 
         it('allows the given value if the validator returns true', async function () {
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', () => true);
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            () => true,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2025,8 +2033,10 @@ describe('ModelDataValidator', function () {
 
         it('allows the given value if the validator returns a promise of true', async function () {
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', () => Promise.resolve(true));
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            () => Promise.resolve(true),
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2042,10 +2052,12 @@ describe('ModelDataValidator', function () {
         });
 
         it('throws an error for non-true result from the validator', async function () {
-          const testFn = async (v) => {
+          const testFn = async v => {
             const S = new Schema();
-            S.getService(PropertyValidatorRegistry)
-              .addValidator('validator', () => v);
+            S.getService(PropertyValidatorRegistry).addValidator(
+              'validator',
+              () => v,
+            );
             S.defineModel({
               name: 'model',
               properties: {
@@ -2055,13 +2067,14 @@ describe('ModelDataValidator', function () {
                 },
               },
             });
-            const promise = S.getService(ModelDataValidator)
-              .validate('model', {foo: 'test'});
+            const promise = S.getService(ModelDataValidator).validate('model', {
+              foo: 'test',
+            });
             return expect(promise).to.be.rejectedWith(
               'The property "foo" of the model "model" has an invalid value "test" ' +
-              'that caught by the validator "validator".',
+                'that caught by the validator "validator".',
             );
-          }
+          };
           await testFn('str');
           await testFn('');
           await testFn(10);
@@ -2092,9 +2105,11 @@ describe('ModelDataValidator', function () {
             });
             validated = true;
             return true;
-          }
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', validator);
+          };
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            validator,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2115,10 +2130,12 @@ describe('ModelDataValidator', function () {
           const validator = function () {
             invoked++;
             return true;
-          }
+          };
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', validator);
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            validator,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2140,10 +2157,12 @@ describe('ModelDataValidator', function () {
             return new Promise((resolve, reject) => {
               setTimeout(() => reject(error), 5);
             });
-          }
+          };
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', validator);
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            validator,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2179,8 +2198,10 @@ describe('ModelDataValidator', function () {
 
         it('do not validate null and undefined values', async function () {
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', () => false);
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            () => false,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2207,10 +2228,12 @@ describe('ModelDataValidator', function () {
         it('throws an error from the validator', async function () {
           const validator = function () {
             throw Error('My error');
-          }
+          };
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', validator);
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            validator,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2284,9 +2307,9 @@ describe('ModelDataValidator', function () {
             });
             return expect(promise).to.be.rejectedWith(
               'The property "foo" of the model "model" has an invalid value "test" ' +
-              'that caught by the validator "validator2".',
+                'that caught by the validator "validator2".',
             );
-          }
+          };
           await testFn('str');
           await testFn('');
           await testFn(10);
@@ -2317,9 +2340,11 @@ describe('ModelDataValidator', function () {
             });
             validated = true;
             return true;
-          }
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', validator);
+          };
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            validator,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2340,11 +2365,11 @@ describe('ModelDataValidator', function () {
           const validator1 = function () {
             invocation.push('validator1');
             return true;
-          }
+          };
           const validator2 = function () {
             invocation.push('validator2');
             return true;
-          }
+          };
           const S = new Schema();
           S.getService(PropertyValidatorRegistry)
             .addValidator('validator1', validator1)
@@ -2367,12 +2392,14 @@ describe('ModelDataValidator', function () {
         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 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)
@@ -2382,10 +2409,7 @@ describe('ModelDataValidator', function () {
             properties: {
               foo: {
                 type: DataType.ANY,
-                validate: [
-                  'validator1',
-                  'validator2',
-                ],
+                validate: ['validator1', 'validator2'],
               },
             },
           });
@@ -2415,8 +2439,10 @@ describe('ModelDataValidator', function () {
 
         it('do not validate null and undefined values', async function () {
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', () => false);
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            () => false,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2449,10 +2475,12 @@ describe('ModelDataValidator', function () {
         it('throws an error from the validator', async function () {
           const validator = function () {
             throw Error('My error');
-          }
+          };
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', validator);
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            validator,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2537,9 +2565,9 @@ describe('ModelDataValidator', function () {
             });
             return expect(promise).to.be.rejectedWith(
               'The property "foo" of the model "model" has an invalid value "test" ' +
-              'that caught by the validator "validator2".',
+                'that caught by the validator "validator2".',
             );
-          }
+          };
           await testFn('str');
           await testFn('');
           await testFn(10);
@@ -2578,9 +2606,11 @@ describe('ModelDataValidator', function () {
             });
             validated = true;
             return true;
-          }
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', validator);
+          };
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            validator,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2606,11 +2636,11 @@ describe('ModelDataValidator', function () {
           const validator1 = function () {
             invocation.push('validator1');
             return true;
-          }
+          };
           const validator2 = function () {
             invocation.push('validator2');
             return true;
-          }
+          };
           const S = new Schema();
           S.getService(PropertyValidatorRegistry)
             .addValidator('validator1', validator1)
@@ -2638,10 +2668,12 @@ describe('ModelDataValidator', function () {
           const validator = function () {
             validated = true;
             return true;
-          }
+          };
           const S = new Schema();
-          S.getService(PropertyValidatorRegistry)
-            .addValidator('validator', validator);
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'validator',
+            validator,
+          );
           S.defineModel({
             name: 'model',
             properties: {
@@ -2662,12 +2694,14 @@ describe('ModelDataValidator', function () {
         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 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)
@@ -2680,7 +2714,7 @@ describe('ModelDataValidator', function () {
                 validate: {
                   validator1: true,
                   validator2: true,
-                }
+                },
               },
             },
           });