chore: tests refactoring

src/definition/datasource/datasource-definition-validator.spec.js

@@ -7,57 +7,56 @@ const S = new DatasourceDefinitionValidator();
 describe('DatasourceDefinitionValidator', function () {
   describe('validate', function () {
     it('requires a given definition to be an object', function () {
-      const validate = value => () => S.validate(value);
-      const error = value =>
+      const validate = v => () => S.validate(v);
+      const error = v =>
         format(
-          'The datasource definition should be an Object, but %v given.',
-          value,
+          'The datasource definition should be an Object, but %s given.',
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate({name: 'datasource', adapter: 'adapter'})();
     });
 
     it('requires the option "name" as a non-empty string', function () {
-      const validate = name => () => S.validate({name, adapter: 'adapter'});
-      const error = value =>
+      const validate = v => () => S.validate({name: v, adapter: 'adapter'});
+      const error = v =>
         format(
           'The datasource definition requires the option "name" ' +
-            'as a non-empty String, but %v given.',
-          value,
+            'as a non-empty String, but %s given.',
+          v,
         );
-      expect(validate('')).to.throw(error(''));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('')).to.throw(error('""'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate('datasource')();
     });
 
     it('requires the option "adapter" to be a non-empty string', function () {
-      const validate = adapter => () =>
-        S.validate({name: 'datasource', adapter});
-      const error = value =>
+      const validate = v => () => S.validate({name: 'datasource', adapter: v});
+      const error = v =>
         format(
           'The datasource "datasource" requires the option "adapter" ' +
-            'as a non-empty String, but %v given.',
-          value,
+            'as a non-empty String, but %s given.',
+          v,
         );
-      expect(validate('')).to.throw(error(''));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('')).to.throw(error('""'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate('adapter')();
     });
   });

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

@@ -24,16 +24,16 @@ describe('ModelDataValidator', function () {
       };
       const error = given =>
         format(
-          'The data of the model "model" must be an Object, but %v given.',
+          'The data of the model "model" must be an Object, but %s given.',
           given,
         );
-      expect(throwable('string')).to.throw(error('string'));
-      expect(throwable(10)).to.throw(error(10));
-      expect(throwable(true)).to.throw(error(true));
-      expect(throwable(false)).to.throw(error(false));
-      expect(throwable([])).to.throw(error([]));
-      expect(throwable(null)).to.throw(error(null));
-      expect(throwable(undefined)).to.throw(error(undefined));
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(null)).to.throw(error('null'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
     });
 
     it('uses a base model hierarchy to validate a given data', function () {

src/definition/model/model-definition-utils.spec.js

@@ -1456,17 +1456,17 @@ describe('ModelDefinitionUtils', function () {
       const error = v =>
         format(
           'The second argument of ModelDefinitionUtils.excludeObjectKeysByRelationNames ' +
-            'must be an Object, but %v given.',
+            'must be an Object, but %s given.',
           v,
         );
-      expect(throwable('')).to.throw(error(''));
-      expect(throwable('str')).to.throw(error('str'));
-      expect(throwable(10)).to.throw(error(10));
-      expect(throwable(true)).to.throw(error(true));
-      expect(throwable(false)).to.throw(error(false));
-      expect(throwable([])).to.throw(error([]));
-      expect(throwable(undefined)).to.throw(error(undefined));
-      expect(throwable(null)).to.throw(error(null));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
       throwable({})();
       throwable({foo: 'bar'})();
     });

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

@@ -15,117 +15,110 @@ describe('ModelDefinitionValidator', function () {
 
   describe('validate', function () {
     it('requires the given definition to be an object', function () {
-      const validate = value => () => S.validate(value);
-      const error = value =>
-        format(
-          'The model definition should be an Object, but %v given.',
-          value,
-        );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      const validate = v => () => S.validate(v);
+      const error = v =>
+        format('The model definition should be an Object, but %s given.', v);
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate({name: 'model'})();
     });
 
     it('requires the option "name" as a non-empty string', function () {
-      const validate = name => () => S.validate({name});
-      const error = value =>
+      const validate = v => () => S.validate({name: v});
+      const error = v =>
         format(
           'The model definition requires the option "name" ' +
-            'as a non-empty String, but %v given.',
-          value,
+            'as a non-empty String, but %s given.',
+          v,
         );
-      expect(validate('')).to.throw(error(''));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('')).to.throw(error('""'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate('model')();
     });
 
     it('expects the provided option "datasource" to be a string', function () {
-      const validate = datasource => () =>
-        S.validate({name: 'model', datasource});
-      const error = value =>
+      const validate = v => () => S.validate({name: 'model', datasource: v});
+      const error = v =>
         format(
           'The provided option "datasource" of the model "model" ' +
-            'should be a String, but %v given.',
-          value,
+            'should be a String, but %s given.',
+          v,
         );
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
       validate('datasource')();
     });
 
     it('expects the provided option "base" to be a string', function () {
-      const validate = base => () => S.validate({name: 'model', base});
-      const error = value =>
+      const validate = v => () => S.validate({name: 'model', base: v});
+      const error = v =>
         format(
           'The provided option "base" of the model "model" ' +
-            'should be a String, but %v given.',
-          value,
+            'should be a String, but %s given.',
+          v,
         );
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
       validate('base')();
     });
 
     it('expects the provided option "tableName" to be a string', function () {
-      const validate = tableName => () =>
-        S.validate({name: 'model', tableName});
-      const error = value =>
+      const validate = v => () => S.validate({name: 'model', tableName: v});
+      const error = v =>
         format(
           'The provided option "tableName" of the model "model" ' +
-            'should be a String, but %v given.',
-          value,
+            'should be a String, but %s given.',
+          v,
         );
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
       validate('tableName')();
     });
 
     it('expects the provided option "properties" to be an object', function () {
-      const validate = properties => () =>
-        S.validate({name: 'model', properties});
-      const error = value =>
+      const validate = v => () => S.validate({name: 'model', properties: v});
+      const error = v =>
         format(
           'The provided option "properties" of the model "model" ' +
-            'should be an Object, but %v given.',
-          value,
+            'should be an Object, but %s given.',
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
       validate({})();
     });
 
     it('expects the provided option "relations" to be an object', function () {
-      const validate = relations => () =>
-        S.validate({name: 'model', relations});
-      const error = value =>
+      const validate = v => () => S.validate({name: 'model', relations: v});
+      const error = v =>
         format(
           'The provided option "relations" of the model "model" ' +
-            'should be an Object, but %v given.',
-          value,
+            'should be an Object, but %s given.',
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
       validate({})();
     });
 

src/definition/model/properties/default-values-definition-validator.spec.js

@@ -8,39 +8,39 @@ const S = new DefaultValuesDefinitionValidator();
 describe('DefaultValuesDefinitionValidator', function () {
   describe('validate', function () {
     it('requires a first argument to be a non-empty string', function () {
-      const validate = value => () => S.validate(value, {});
-      const error = value =>
+      const validate = v => () => S.validate(v, {});
+      const error = v =>
         format(
           'A first argument of DefaultValuesDefinitionValidator.validate ' +
-            'should be a non-empty String, but %v given.',
-          value,
+            'should be a non-empty String, but %s given.',
+          v,
         );
-      expect(validate('')).to.throw(error(''));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('')).to.throw(error('""'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate('model')();
     });
 
     it('requires a second argument to be an object', function () {
-      const validate = value => () => S.validate('model', value);
-      const error = value =>
+      const validate = v => () => S.validate('model', v);
+      const error = v =>
         format(
           'The provided option "properties" of the model "model" ' +
-            'should be an Object, but %v given.',
-          value,
+            'should be an Object, but %s given.',
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate({})();
     });
 

src/definition/model/properties/properties-definition-validator.spec.js

@@ -16,246 +16,246 @@ describe('PropertiesDefinitionValidator', function () {
 
   describe('validate', function () {
     it('requires a first argument to be a non-empty string', function () {
-      const validate = value => () => S.validate(value, {});
-      const error = value =>
+      const validate = v => () => S.validate(v, {});
+      const error = v =>
         format(
           'A first argument of PropertiesDefinitionValidator.validate ' +
-            'should be a non-empty String, but %v given.',
-          value,
+            'should be a non-empty String, but %s given.',
+          v,
         );
-      expect(validate('')).to.throw(error(''));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('')).to.throw(error('""'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate('model')();
     });
 
     it('requires a second argument to be an object', function () {
-      const validate = value => () => S.validate('model', value);
-      const error = value =>
+      const validate = v => () => S.validate('model', v);
+      const error = v =>
         format(
           'The provided option "properties" of the model "model" ' +
-            'should be an Object, but %v given.',
-          value,
+            'should be an Object, but %s given.',
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate({})();
     });
 
     it('requires a property name as a non-empty string', function () {
-      const validate = properties => () => S.validate('model', properties);
-      const error = value =>
+      const validate = v => () => S.validate('model', v);
+      const error = v =>
         format(
           'The property name of the model "model" should be ' +
-            'a non-empty String, but %v given.',
-          value,
+            'a non-empty String, but %s given.',
+          v,
         );
-      expect(validate({['']: {}})).to.throw(error(''));
+      expect(validate({['']: {}})).to.throw(error('""'));
       validate({foo: DataType.STRING})();
     });
 
     it('requires a property definition', function () {
-      const validate = foo => () => S.validate('model', {foo});
-      const error = value =>
+      const validate = v => () => S.validate('model', {foo: v});
+      const error = v =>
         format(
           'The property "foo" of the model "model" should have ' +
-            'a property definition, but %v given.',
-          value,
+            'a property definition, but %s given.',
+          v,
         );
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate(DataType.STRING)();
       validate({type: DataType.STRING})();
     });
 
     it('expects a short property definition to be DataType', function () {
-      const validate = foo => () => S.validate('model', {foo});
-      const error = value =>
+      const validate = v => () => S.validate('model', {foo: v});
+      const error = v =>
         format(
           'In case of a short property definition, the property "foo" ' +
-            'of the model "model" should have one of data types: %l, but %v given.',
+            'of the model "model" should have one of data types: %l, but %s given.',
           Object.values(DataType),
-          value,
+          v,
         );
-      expect(validate('invalid')).to.throw(error('invalid'));
+      expect(validate('invalid')).to.throw(error('"invalid"'));
       validate(DataType.STRING)();
     });
 
     it('expects a full property definition to be an object', function () {
-      const validate = foo => () => S.validate('model', {foo});
-      const error = value =>
+      const validate = v => () => S.validate('model', {foo: v});
+      const error = v =>
         format(
           'In case of a full property definition, the property "foo" ' +
-            'of the model "model" should be an Object, but %v given.',
-          value,
+            'of the model "model" should be an Object, but %s given.',
+          v,
         );
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
       validate({type: DataType.STRING})();
     });
 
     it('requires the option "type" to be a DataType', function () {
-      const validate = type => () => S.validate('model', {foo: {type}});
-      const error = value =>
+      const validate = v => () => S.validate('model', {foo: {type: v}});
+      const error = v =>
         format(
           'The property "foo" of the model "model" requires the option "type" ' +
-            'to have one of data types: %l, but %v given.',
+            'to have one of data types: %l, but %s given.',
           Object.values(DataType),
-          value,
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate(DataType.STRING)();
     });
 
     it('expects provided the option "itemType" to be a DataType', function () {
-      const validate = itemType => {
-        const foo = {type: DataType.ARRAY, itemType};
+      const validate = v => {
+        const foo = {type: DataType.ARRAY, itemType: v};
         return () => S.validate('model', {foo});
       };
-      const error = value =>
+      const error = v =>
         format(
           'The provided option "itemType" of the property "foo" in the model "model" ' +
-            'should have one of data types: %l, but %v given.',
+            'should have one of data types: %l, but %s given.',
           Object.values(DataType),
-          value,
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
       validate(DataType.STRING)();
     });
 
     it('expects provided the option "model" to be a string', function () {
-      const validate = model => {
+      const validate = v => {
         const foo = {
           type: DataType.OBJECT,
-          model,
+          model: v,
         };
         return () => S.validate('model', {foo});
       };
-      const error = value =>
+      const error = v =>
         format(
           'The provided option "model" of the property "foo" in the model "model" ' +
-            'should be a String, but %v given.',
-          value,
+            'should be a String, but %s given.',
+          v,
         );
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
       validate('model')();
     });
 
     it('expects provided the option "primaryKey" to be a boolean', function () {
-      const validate = primaryKey => {
+      const validate = v => {
         const foo = {
           type: DataType.STRING,
-          primaryKey,
+          primaryKey: v,
         };
         return () => S.validate('model', {foo});
       };
-      const error = value =>
+      const error = v =>
         format(
           'The provided option "primaryKey" of the property "foo" in the model "model" ' +
-            'should be a Boolean, but %v given.',
-          value,
+            'should be a Boolean, but %s given.',
+          v,
         );
-      expect(validate(10)).to.throw(error(10));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
       validate(true)();
       validate(false)();
     });
 
     it('expects provided the option "columnName" to be a string', function () {
-      const validate = columnName => {
+      const validate = v => {
         const foo = {
           type: DataType.STRING,
-          columnName,
+          columnName: v,
         };
         return () => S.validate('model', {foo});
       };
-      const error = value =>
+      const error = v =>
         format(
           'The provided option "columnName" of the property "foo" in the model "model" ' +
-            'should be a String, but %v given.',
-          value,
+            'should be a String, but %s given.',
+          v,
         );
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
       validate('columnName')();
     });
 
     it('expects provided the option "columnType" to be a string', function () {
-      const validate = columnType => {
+      const validate = v => {
         const foo = {
           type: DataType.STRING,
-          columnType,
+          columnType: v,
         };
         return () => S.validate('model', {foo});
       };
-      const error = value =>
+      const error = v =>
         format(
           'The provided option "columnType" of the property "foo" in the model "model" ' +
-            'should be a String, but %v given.',
-          value,
+            'should be a String, but %s given.',
+          v,
         );
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
       validate('columnType')();
     });
 
     it('expects provided the option "required" to be a boolean', function () {
-      const validate = required => {
+      const validate = v => {
         const foo = {
           type: DataType.STRING,
-          required,
+          required: v,
         };
         return () => S.validate('model', {foo});
       };
-      const error = value =>
+      const error = v =>
         format(
           'The provided option "required" of the property "foo" in the model "model" ' +
-            'should be a Boolean, but %v given.',
-          value,
+            'should be a Boolean, but %s given.',
+          v,
         );
-      expect(validate(10)).to.throw(error(10));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
       validate(true)();
       validate(false)();
     });
 
     it('expects the required property should not have the option "default" to be provided', function () {
-      const validate = value => () => {
+      const validate = v => () => {
         const foo = {
           type: DataType.ANY,
           required: true,
-          default: value,
+          default: v,
         };
         S.validate('model', {foo});
       };
@@ -274,11 +274,11 @@ describe('PropertiesDefinitionValidator', function () {
     });
 
     it('expects the primary key should not have the option "required" to be true', function () {
-      const validate = required => () => {
+      const validate = v => () => {
         const foo = {
           type: DataType.ANY,
           primaryKey: true,
-          required,
+          required: v,
         };
         S.validate('model', {foo});
       };
@@ -292,11 +292,11 @@ describe('PropertiesDefinitionValidator', function () {
     });
 
     it('expects the primary key should not have the option "default" to be provided', function () {
-      const validate = value => () => {
+      const validate = v => () => {
         const foo = {
           type: DataType.ANY,
           primaryKey: true,
-          default: value,
+          default: v,
         };
         S.validate('model', {foo});
       };
@@ -315,9 +315,9 @@ describe('PropertiesDefinitionValidator', function () {
     });
 
     it('expects a non-array property should not have the option "itemType" to be provided', function () {
-      const validate = type => () => {
+      const validate = v => () => {
         const foo = {
-          type,
+          type: v,
           itemType: DataType.STRING,
         };
         S.validate('model', {foo});
@@ -334,9 +334,9 @@ describe('PropertiesDefinitionValidator', function () {
     });
 
     it('expects a non-object property should not have the option "model" to be provided', function () {
-      const validate = type => () => {
+      const validate = v => () => {
         const foo = {
-          type,
+          type: v,
           model: 'model',
         };
         S.validate('model', {foo});

src/definition/model/relations/relations-definition-validator.spec.js

@@ -8,143 +8,143 @@ const S = new RelationsDefinitionValidator();
 describe('RelationsDefinitionValidator', function () {
   describe('validate', function () {
     it('requires a first argument to be a non-empty string', function () {
-      const validate = value => () => S.validate(value, {});
-      const error = value =>
+      const validate = v => () => S.validate(v, {});
+      const error = v =>
         format(
           'A first argument of RelationsDefinitionValidator.validate ' +
-            'should be a non-empty String, but %v given.',
-          value,
+            'should be a non-empty String, but %s given.',
+          v,
         );
-      expect(validate('')).to.throw(error(''));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('')).to.throw(error('""'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate('model')();
     });
 
     it('requires a second argument to be an object', function () {
-      const validate = value => () => S.validate('model', value);
-      const error = value =>
+      const validate = v => () => S.validate('model', v);
+      const error = v =>
         format(
           'The provided option "relations" of the model "model" ' +
-            'should be an Object, but %v given.',
-          value,
+            'should be an Object, but %s given.',
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate({})();
     });
 
     it('requires a relation name to be a non-empty string', function () {
-      const validate = relations => () => S.validate('model', relations);
-      const error = value =>
+      const validate = v => () => S.validate('model', v);
+      const error = v =>
         format(
           'The relation name of the model "model" should be ' +
-            'a non-empty String, but %v given.',
-          value,
+            'a non-empty String, but %s given.',
+          v,
         );
-      expect(validate({['']: {}})).to.throw(error(''));
+      expect(validate({['']: {}})).to.throw(error('""'));
       validate({foo: {type: RelationType.BELONGS_TO, model: 'model'}})();
     });
 
     it('requires a relation definition to be an object', function () {
-      const validate = foo => () => S.validate('model', {foo});
-      const error = value =>
+      const validate = v => () => S.validate('model', {foo: v});
+      const error = v =>
         format(
           'The relation "foo" of the model "model" should ' +
-            'be an Object, but %v given.',
-          value,
+            'be an Object, but %s given.',
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate({type: RelationType.BELONGS_TO, model: 'model'})();
     });
 
     it('requires the option "type" to be a RelationType', function () {
-      const validate = type => () => {
-        const foo = {type, model: 'model'};
+      const validate = v => () => {
+        const foo = {type: v, model: 'model'};
         S.validate('model', {foo});
       };
-      const error = value =>
+      const error = v =>
         format(
           'The relation "foo" of the model "model" requires the option "type" ' +
-            'to have one of relation types: %l, but %v given.',
+            'to have one of relation types: %l, but %s given.',
           Object.values(RelationType),
-          value,
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate(false)).to.throw(error(false));
-      expect(validate([])).to.throw(error([]));
-      expect(validate({})).to.throw(error({}));
-      expect(validate(undefined)).to.throw(error(undefined));
-      expect(validate(null)).to.throw(error(null));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
       validate(RelationType.BELONGS_TO)();
     });
 
     describe('belongsTo', function () {
       describe('a regular relation', function () {
         it('requires the option "model" to be a non-empty string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.BELONGS_TO,
-              model: value,
+              model: v,
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "belongsTo", ' +
                 'so it requires the option "model" to be a non-empty String, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('model')();
         });
 
         it('expects the provided option "foreignKey" to be a string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.BELONGS_TO,
               model: 'model',
-              foreignKey: value,
+              foreignKey: v,
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "belongsTo", ' +
                 'so it expects the provided option "foreignKey" to be a String, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
           validate('foreignKey')();
           validate('')();
           validate(false)();
@@ -170,47 +170,47 @@ describe('RelationsDefinitionValidator', function () {
 
       describe('a polymorphic relation', function () {
         it('requires the option "polymorphic" to be a boolean', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.BELONGS_TO,
-              polymorphic: value,
+              polymorphic: v,
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "belongsTo", ' +
                 'so it expects the option "polymorphic" to be a Boolean, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate('str')).to.throw(error('str'));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate([])).to.throw(error([]));
-          expect(validate({})).to.throw(error({}));
+          expect(validate('str')).to.throw(error('"str"'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate({})).to.throw(error('Object'));
           validate(true)();
         });
 
         it('expects the provided option "foreignKey" to be a string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.BELONGS_TO,
               polymorphic: true,
-              foreignKey: value,
+              foreignKey: v,
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" is a polymorphic "belongsTo" relation, ' +
                 'so it expects the provided option "foreignKey" to be a String, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
           validate('foreignKey')();
           validate('')();
           validate(false)();
@@ -219,25 +219,25 @@ describe('RelationsDefinitionValidator', function () {
         });
 
         it('expects the provided option "discriminator" to be a string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.BELONGS_TO,
               polymorphic: true,
-              discriminator: value,
+              discriminator: v,
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" is a polymorphic "belongsTo" relation, ' +
                 'so it expects the provided option "discriminator" to be a String, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
           validate('discriminator')();
           validate('')();
           validate(false)();
@@ -250,56 +250,56 @@ describe('RelationsDefinitionValidator', function () {
     describe('hasOne', function () {
       describe('a regular relation', function () {
         it('requires the option "model" to be a non-empty string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.HAS_ONE,
               model: 'model',
-              foreignKey: value,
+              foreignKey: v,
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "hasOne", ' +
                 'so it requires the option "foreignKey" to be a non-empty String, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('modelId')();
         });
 
         it('requires the option "foreignKey" to be a string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.HAS_ONE,
-              model: value,
+              model: v,
               foreignKey: 'modelId',
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "hasOne", ' +
                 'so it requires the option "model" to be a non-empty String, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('model')();
         });
 
@@ -322,29 +322,29 @@ describe('RelationsDefinitionValidator', function () {
 
       describe('a polymorphic relation with a target relation name', function () {
         it('requires the option "model" to be a non-empty string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.HAS_ONE,
-              model: value,
+              model: v,
               polymorphic: 'reference',
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "hasOne", ' +
                 'so it requires the option "model" to be a non-empty String, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('model')();
         });
 
@@ -385,89 +385,89 @@ describe('RelationsDefinitionValidator', function () {
 
       describe('a polymorphic relation with target relation keys', function () {
         it('requires the option "model" to be a non-empty string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.HAS_ONE,
-              model: value,
+              model: v,
               polymorphic: true,
               foreignKey: 'referenceId',
               discriminator: 'referenceType',
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "hasOne", ' +
                 'so it requires the option "model" to be a non-empty String, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('model')();
         });
 
         it('requires the option "foreignKey" to be a non-empty string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.HAS_ONE,
               model: 'model',
               polymorphic: true,
-              foreignKey: value,
+              foreignKey: v,
               discriminator: 'referenceType',
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the option "polymorphic" ' +
                 'with "true" value, so it requires the option "foreignKey" ' +
-                'to be a non-empty String, but %v given.',
-              value,
+                'to be a non-empty String, but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('referenceId')();
         });
 
         it('requires the option "discriminator" to be a non-empty string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.HAS_ONE,
               model: 'model',
               polymorphic: true,
               foreignKey: 'referenceId',
-              discriminator: value,
+              discriminator: v,
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the option "polymorphic" ' +
                 'with "true" value, so it requires the option "discriminator" ' +
-                'to be a non-empty String, but %v given.',
-              value,
+                'to be a non-empty String, but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('referenceType')();
         });
       });
@@ -476,56 +476,56 @@ describe('RelationsDefinitionValidator', function () {
     describe('hasMany', function () {
       describe('a regular relation', function () {
         it('requires the option "model" to be a non-empty string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.HAS_MANY,
               model: 'model',
-              foreignKey: value,
+              foreignKey: v,
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "hasMany", ' +
                 'so it requires the option "foreignKey" to be a non-empty String, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('modelId')();
         });
 
         it('requires the option "foreignKey" to be a string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.HAS_MANY,
-              model: value,
+              model: v,
               foreignKey: 'modelId',
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "hasMany", ' +
                 'so it requires the option "model" to be a non-empty String, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('model')();
         });
 
@@ -548,29 +548,29 @@ describe('RelationsDefinitionValidator', function () {
 
       describe('a polymorphic relation with a target relation name', function () {
         it('requires the option "model" to be a non-empty string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.HAS_MANY,
-              model: value,
+              model: v,
               polymorphic: 'reference',
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "hasMany", ' +
                 'so it requires the option "model" to be a non-empty String, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('model')();
         });
 
@@ -611,89 +611,89 @@ describe('RelationsDefinitionValidator', function () {
 
       describe('a polymorphic relation with target relation keys', function () {
         it('requires the option "model" to be a non-empty string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.HAS_MANY,
-              model: value,
+              model: v,
               polymorphic: true,
               foreignKey: 'referenceId',
               discriminator: 'referenceType',
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "hasMany", ' +
                 'so it requires the option "model" to be a non-empty String, ' +
-                'but %v given.',
-              value,
+                'but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('model')();
         });
 
         it('requires the option "foreignKey" to be a non-empty string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.HAS_MANY,
               model: 'model',
               polymorphic: true,
-              foreignKey: value,
+              foreignKey: v,
               discriminator: 'referenceType',
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the option "polymorphic" ' +
                 'with "true" value, so it requires the option "foreignKey" ' +
-                'to be a non-empty String, but %v given.',
-              value,
+                'to be a non-empty String, but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('referenceId')();
         });
 
         it('requires the option "discriminator" to be a non-empty string', function () {
-          const validate = value => {
+          const validate = v => {
             const foo = {
               type: RelationType.HAS_MANY,
               model: 'model',
               polymorphic: true,
               foreignKey: 'referenceId',
-              discriminator: value,
+              discriminator: v,
             };
             return () => S.validate('model', {foo});
           };
-          const error = value =>
+          const error = v =>
             format(
               'The relation "foo" of the model "model" has the option "polymorphic" ' +
                 'with "true" value, so it requires the option "discriminator" ' +
-                'to be a non-empty String, but %v given.',
-              value,
+                'to be a non-empty String, but %s given.',
+              v,
             );
-          expect(validate('')).to.throw(error(''));
-          expect(validate(10)).to.throw(error(10));
-          expect(validate(true)).to.throw(error(true));
-          expect(validate(false)).to.throw(error(false));
-          expect(validate({})).to.throw(error({}));
-          expect(validate([])).to.throw(error([]));
-          expect(validate(undefined)).to.throw(error(undefined));
-          expect(validate(null)).to.throw(error(null));
+          expect(validate('')).to.throw(error('""'));
+          expect(validate(10)).to.throw(error('10'));
+          expect(validate(true)).to.throw(error('true'));
+          expect(validate(false)).to.throw(error('false'));
+          expect(validate({})).to.throw(error('Object'));
+          expect(validate([])).to.throw(error('Array'));
+          expect(validate(undefined)).to.throw(error('undefined'));
+          expect(validate(null)).to.throw(error('null'));
           validate('referenceType')();
         });
       });
@@ -701,51 +701,51 @@ describe('RelationsDefinitionValidator', function () {
 
     describe('referencesMany', function () {
       it('requires the option "model" to be a non-empty string', function () {
-        const validate = value => {
+        const validate = v => {
           const foo = {
             type: RelationType.REFERENCES_MANY,
-            model: value,
+            model: v,
           };
           return () => S.validate('model', {foo});
         };
-        const error = value =>
+        const error = v =>
           format(
             'The relation "foo" of the model "model" has the type "referencesMany", ' +
               'so it requires the option "model" to be a non-empty String, ' +
-              'but %v given.',
-            value,
+              'but %s given.',
+            v,
           );
-        expect(validate('')).to.throw(error(''));
-        expect(validate(10)).to.throw(error(10));
-        expect(validate(true)).to.throw(error(true));
-        expect(validate(false)).to.throw(error(false));
-        expect(validate({})).to.throw(error({}));
-        expect(validate([])).to.throw(error([]));
-        expect(validate(undefined)).to.throw(error(undefined));
-        expect(validate(null)).to.throw(error(null));
+        expect(validate('')).to.throw(error('""'));
+        expect(validate(10)).to.throw(error('10'));
+        expect(validate(true)).to.throw(error('true'));
+        expect(validate(false)).to.throw(error('false'));
+        expect(validate({})).to.throw(error('Object'));
+        expect(validate([])).to.throw(error('Array'));
+        expect(validate(undefined)).to.throw(error('undefined'));
+        expect(validate(null)).to.throw(error('null'));
         validate('model')();
       });
 
       it('expects the provided option "foreignKey" to be a string', function () {
-        const validate = value => {
+        const validate = v => {
           const foo = {
             type: RelationType.REFERENCES_MANY,
             model: 'model',
-            foreignKey: value,
+            foreignKey: v,
           };
           return () => S.validate('model', {foo});
         };
-        const error = value =>
+        const error = v =>
           format(
             'The relation "foo" of the model "model" has the type "referencesMany", ' +
               'so it expects the provided option "foreignKey" to be a String, ' +
-              'but %v given.',
-            value,
+              'but %s given.',
+            v,
           );
-        expect(validate(10)).to.throw(error(10));
-        expect(validate(true)).to.throw(error(true));
-        expect(validate({})).to.throw(error({}));
-        expect(validate([])).to.throw(error([]));
+        expect(validate(10)).to.throw(error('10'));
+        expect(validate(true)).to.throw(error('true'));
+        expect(validate({})).to.throw(error('Object'));
+        expect(validate([])).to.throw(error('Array'));
         validate('foreignKey')();
         validate('')();
         validate(false)();

src/errors/invalid-argument-error.spec.js

@@ -17,17 +17,17 @@ describe('InvalidArgumentError', function () {
     const throwable = v => () => {
       throw new InvalidArgumentError('%v', v);
     };
-    const error = v => format('%v', v);
-    expect(throwable('str')).to.throw(error('str'));
-    expect(throwable('')).to.throw(error(''));
-    expect(throwable(10)).to.throw(error(10));
+    const error = v => format('%s', v);
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable(10)).to.throw(error('10'));
     expect(throwable(0)).to.throw(error(0));
-    expect(throwable(true)).to.throw(error(true));
-    expect(throwable(false)).to.throw(error(false));
-    expect(throwable({})).to.throw(error({}));
-    expect(throwable([])).to.throw(error([]));
-    expect(throwable(undefined)).to.throw(error(undefined));
-    expect(throwable(null)).to.throw(error(null));
-    expect(throwable(() => undefined)).to.throw(error(() => undefined));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
+    expect(throwable(null)).to.throw(error('null'));
+    expect(throwable(() => undefined)).to.throw(error('Function'));
   });
 });

src/errors/not-implemented-error.spec.js

@@ -17,17 +17,17 @@ describe('NotImplementedError', function () {
     const throwable = v => () => {
       throw new NotImplementedError('%v', v);
     };
-    const error = v => format('%v', v);
-    expect(throwable('str')).to.throw(error('str'));
-    expect(throwable('')).to.throw(error(''));
-    expect(throwable(10)).to.throw(error(10));
+    const error = v => format('%s', v);
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable(10)).to.throw(error('10'));
     expect(throwable(0)).to.throw(error(0));
-    expect(throwable(true)).to.throw(error(true));
-    expect(throwable(false)).to.throw(error(false));
-    expect(throwable({})).to.throw(error({}));
-    expect(throwable([])).to.throw(error([]));
-    expect(throwable(undefined)).to.throw(error(undefined));
-    expect(throwable(null)).to.throw(error(null));
-    expect(throwable(() => undefined)).to.throw(error(() => undefined));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
+    expect(throwable(null)).to.throw(error('null'));
+    expect(throwable(() => undefined)).to.throw(error('Function'));
   });
 });

src/filter/fields-clause-tool.spec.js

@@ -73,23 +73,22 @@ describe('FieldsClauseTool', function () {
 
   describe('validateFieldsClause', function () {
     it('requires a non-empty string or an array of non-empty strings', function () {
-      const validate = clause => () =>
-        FieldsClauseTool.validateFieldsClause(clause);
-      const error = value =>
+      const validate = v => () => FieldsClauseTool.validateFieldsClause(v);
+      const error = v =>
         format(
           'The provided option "fields" should be a non-empty String ' +
-            'or an Array of String, but %v given.',
-          value,
+            'or an Array of String, but %s given.',
+          v,
         );
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate({})).to.throw(error({}));
-      expect(validate([''])).to.throw(error(''));
-      expect(validate([10])).to.throw(error(10));
-      expect(validate([true])).to.throw(error(true));
-      expect(validate([false])).to.throw(error(false));
-      expect(validate([undefined])).to.throw(error(undefined));
-      expect(validate([null])).to.throw(error(null));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate({})).to.throw(error('Object'));
+      expect(validate([''])).to.throw(error('""'));
+      expect(validate([10])).to.throw(error('10'));
+      expect(validate([true])).to.throw(error('true'));
+      expect(validate([false])).to.throw(error('false'));
+      expect(validate([undefined])).to.throw(error('undefined'));
+      expect(validate([null])).to.throw(error('null'));
       validate('');
       validate(false);
       validate(undefined);
@@ -108,21 +107,21 @@ describe('FieldsClauseTool', function () {
 
     it('requires a non-empty string or an array of non-empty strings', function () {
       const fn = clause => () => FieldsClauseTool.normalizeFieldsClause(clause);
-      const error = value =>
+      const error = v =>
         format(
           'The provided option "fields" should be a non-empty String ' +
-            'or an Array of String, but %v given.',
-          value,
+            'or an Array of String, but %s given.',
+          v,
         );
-      expect(fn(10)).to.throw(error(10));
-      expect(fn(true)).to.throw(error(true));
-      expect(fn({})).to.throw(error({}));
-      expect(fn([''])).to.throw(error(''));
-      expect(fn([10])).to.throw(error(10));
-      expect(fn([true])).to.throw(error(true));
-      expect(fn([false])).to.throw(error(false));
-      expect(fn([undefined])).to.throw(error(undefined));
-      expect(fn([null])).to.throw(error(null));
+      expect(fn(10)).to.throw(error('10'));
+      expect(fn(true)).to.throw(error('true'));
+      expect(fn({})).to.throw(error('Object'));
+      expect(fn([''])).to.throw(error('""'));
+      expect(fn([10])).to.throw(error('10'));
+      expect(fn([true])).to.throw(error('true'));
+      expect(fn([false])).to.throw(error('false'));
+      expect(fn([undefined])).to.throw(error('undefined'));
+      expect(fn([null])).to.throw(error('null'));
       expect(fn('')()).to.be.undefined;
       expect(fn(false)()).to.be.undefined;
       expect(fn(undefined)()).to.be.undefined;

src/filter/operator-clause-tool.spec.js

@@ -1049,11 +1049,11 @@ describe('OperatorClauseTool', function () {
       const throwable = v => () =>
         S.testRegexp({regexp: 'Val.+', flags: v}, 'val');
       const error = v =>
-        format('RegExp flags must be a String, but %v given.', v);
-      expect(throwable(10)).to.throw(error(10));
-      expect(throwable(true)).to.throw(error(true));
-      expect(throwable([])).to.throw(error([]));
-      expect(throwable({})).to.throw(error({}));
+        format('RegExp flags must be a String, but %s given.', v);
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable({})).to.throw(error('Object'));
       throwable('')();
       throwable(0)();
       throwable(false)();

src/filter/order-clause-tool.spec.js

@@ -378,23 +378,22 @@ describe('OrderClauseTool', function () {
 
   describe('validateOrderClause', function () {
     it('requires a non-empty string or an array of non-empty strings', function () {
-      const validate = clause => () =>
-        OrderClauseTool.validateOrderClause(clause);
-      const error = value =>
+      const validate = v => () => OrderClauseTool.validateOrderClause(v);
+      const error = v =>
         format(
           'The provided option "order" should be a non-empty String ' +
-            'or an Array of String, but %v given.',
-          value,
+            'or an Array of String, but %s given.',
+          v,
         );
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate({})).to.throw(error({}));
-      expect(validate([''])).to.throw(error(''));
-      expect(validate([10])).to.throw(error(10));
-      expect(validate([true])).to.throw(error(true));
-      expect(validate([false])).to.throw(error(false));
-      expect(validate([undefined])).to.throw(error(undefined));
-      expect(validate([null])).to.throw(error(null));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate({})).to.throw(error('Object'));
+      expect(validate([''])).to.throw(error('""'));
+      expect(validate([10])).to.throw(error('10'));
+      expect(validate([true])).to.throw(error('true'));
+      expect(validate([false])).to.throw(error('false'));
+      expect(validate([undefined])).to.throw(error('undefined'));
+      expect(validate([null])).to.throw(error('null'));
       validate('');
       validate(false);
       validate(undefined);
@@ -413,21 +412,21 @@ describe('OrderClauseTool', function () {
 
     it('requires a non-empty string or an array of non-empty strings', function () {
       const fn = clause => () => OrderClauseTool.normalizeOrderClause(clause);
-      const error = value =>
+      const error = v =>
         format(
           'The provided option "order" should be a non-empty String ' +
-            'or an Array of String, but %v given.',
-          value,
+            'or an Array of String, but %s given.',
+          v,
         );
-      expect(fn(10)).to.throw(error(10));
-      expect(fn(true)).to.throw(error(true));
-      expect(fn({})).to.throw(error({}));
-      expect(fn([''])).to.throw(error(''));
-      expect(fn([10])).to.throw(error(10));
-      expect(fn([true])).to.throw(error(true));
-      expect(fn([false])).to.throw(error(false));
-      expect(fn([undefined])).to.throw(error(undefined));
-      expect(fn([null])).to.throw(error(null));
+      expect(fn(10)).to.throw(error('10'));
+      expect(fn(true)).to.throw(error('true'));
+      expect(fn({})).to.throw(error('Object'));
+      expect(fn([''])).to.throw(error('""'));
+      expect(fn([10])).to.throw(error('10'));
+      expect(fn([true])).to.throw(error('true'));
+      expect(fn([false])).to.throw(error('false'));
+      expect(fn([undefined])).to.throw(error('undefined'));
+      expect(fn([null])).to.throw(error('null'));
       expect(fn('')()).to.be.undefined;
       expect(fn(false)()).to.be.undefined;
       expect(fn(undefined)()).to.be.undefined;

src/filter/slice-clause-tool.spec.js

@@ -77,16 +77,15 @@ describe('SliceClauseTool', function () {
 
   describe('validateSkipClause', function () {
     it('requires a number value or a falsy value', function () {
-      const validate = clause => () =>
-        SliceClauseTool.validateSkipClause(clause);
-      const error = value =>
+      const validate = v => () => SliceClauseTool.validateSkipClause(v);
+      const error = v =>
         format(
-          'The provided option "skip" should be a Number, but %v given.',
-          value,
+          'The provided option "skip" should be a Number, but %s given.',
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
       validate('');
       validate(false);
       validate(undefined);
@@ -98,16 +97,15 @@ describe('SliceClauseTool', function () {
 
   describe('validateLimitClause', function () {
     it('requires a number value or a falsy value', function () {
-      const validate = clause => () =>
-        SliceClauseTool.validateLimitClause(clause);
-      const error = value =>
+      const validate = v => () => SliceClauseTool.validateLimitClause(v);
+      const error = v =>
         format(
-          'The provided option "limit" should be a Number, but %v given.',
-          value,
+          'The provided option "limit" should be a Number, but %s given.',
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
       validate('');
       validate(false);
       validate(undefined);

src/filter/where-clause-tool.spec.js

@@ -260,17 +260,16 @@ describe('WhereClauseTool', function () {
 
   describe('validateWhereClause', function () {
     it('requires an object value or a falsy value', function () {
-      const validate = clause => () =>
-        WhereClauseTool.validateWhereClause(clause);
-      const error = value =>
+      const validate = v => () => WhereClauseTool.validateWhereClause(v);
+      const error = v =>
         format(
-          'The provided option "where" should be an Object, but %v given.',
-          value,
+          'The provided option "where" should be an Object, but %s given.',
+          v,
         );
-      expect(validate('str')).to.throw(error('str'));
-      expect(validate(10)).to.throw(error(10));
-      expect(validate(true)).to.throw(error(true));
-      expect(validate([])).to.throw(error([]));
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
       validate('');
       validate(false);
       validate(undefined);

src/relations/belongs-to-resolver.spec.js

@@ -14,19 +14,19 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of BelongsToResolver.includeTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo(v, 'sourceName', 'targetName', 'relationName');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires elements of the "entities" parameter to be an Object', async function () {
@@ -35,19 +35,19 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of BelongsToResolver.includeTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([v], 'sourceName', 'targetName', 'relationName');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "sourceName" parameter to be a non-empty string', async function () {
@@ -56,18 +56,18 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The parameter "sourceName" of BelongsToResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v => R.includeTo([], v, 'targetName', 'relationName');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "targetName" parameter to be a non-empty string', async function () {
@@ -76,18 +76,18 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The parameter "targetName" of BelongsToResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v => R.includeTo([], 'sourceName', v, 'relationName');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "relationName" parameter to be a non-empty string', async function () {
@@ -96,18 +96,18 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The parameter "relationName" of BelongsToResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v => R.includeTo([], 'sourceName', 'targetName', v);
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the provided parameter "foreignKey" to be a string', async function () {
@@ -116,15 +116,15 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The provided parameter "foreignKey" of BelongsToResolver.includeTo ' +
-            'should be a String, but %v given.',
+            'should be a String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([], 'sourceName', 'targetName', 'relationName', v);
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
     });
 
     it('requires the provided parameter "scope" to be an object', async function () {
@@ -133,7 +133,7 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The provided parameter "scope" of BelongsToResolver.includeTo ' +
-            'should be an Object, but %v given.',
+            'should be an Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -145,10 +145,10 @@ describe('BelongsToResolver', function () {
           undefined,
           v,
         );
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
     });
 
     it('throws an error if the given target model is not found', async function () {
@@ -528,19 +528,19 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of BelongsToResolver.includePolymorphicTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
         R.includePolymorphicTo(v, 'sourceName', 'relationName');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires elements of the "entities" parameter to be an Object', async function () {
@@ -549,19 +549,19 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of BelongsToResolver.includePolymorphicTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
         R.includePolymorphicTo([v], 'sourceName', 'relationName');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "sourceName" parameter to be a non-empty string', async function () {
@@ -570,19 +570,19 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The parameter "sourceName" of BelongsToResolver.includePolymorphicTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includePolymorphicTo([], v, 'sourceName', 'relationName');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "relationName" parameter to be a non-empty string', async function () {
@@ -591,18 +591,18 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The parameter "relationName" of BelongsToResolver.includePolymorphicTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v => R.includePolymorphicTo([], 'sourceName', v);
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the provided parameter "foreignKey" to be a string', async function () {
@@ -611,15 +611,15 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The provided parameter "foreignKey" of BelongsToResolver.includePolymorphicTo ' +
-            'should be a String, but %v given.',
+            'should be a String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includePolymorphicTo([], 'sourceName', 'relationName', v);
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
     });
 
     it('requires the provided parameter "discriminator" to be a string', async function () {
@@ -628,15 +628,15 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The provided parameter "discriminator" of BelongsToResolver.includePolymorphicTo ' +
-            'should be a String, but %v given.',
+            'should be a String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includePolymorphicTo([], 'sourceName', 'relationName', undefined, v);
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
     });
 
     it('requires the provided parameter "scope" to be an object', async function () {
@@ -645,7 +645,7 @@ describe('BelongsToResolver', function () {
       const error = v =>
         format(
           'The provided parameter "scope" of BelongsToResolver.includePolymorphicTo ' +
-            'should be an Object, but %v given.',
+            'should be an Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -657,10 +657,10 @@ describe('BelongsToResolver', function () {
           undefined,
           v,
         );
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
     });
 
     it('does not throw an error if a target model is not found', async function () {

src/relations/has-many-resolver.spec.js

@@ -14,7 +14,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of HasManyResolver.includeTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -25,14 +25,14 @@ describe('HasManyResolver', function () {
           'relationName',
           'foreignKey',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires elements of the "entities" parameter to be an Object', async function () {
@@ -42,19 +42,19 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of HasManyResolver.includeTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([v], 'source', 'target', 'relationName', 'foreignKey');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "sourceName" parameter to be a non-empty string', async function () {
@@ -63,19 +63,19 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "sourceName" of HasManyResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([], v, 'targetName', 'relationName', 'foreignKey');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "targetName" parameter to be a non-empty string', async function () {
@@ -84,19 +84,19 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "targetName" of HasManyResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([], 'sourceName', v, 'relationName', 'foreignKey');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "relationName" parameter to be a non-empty string', async function () {
@@ -105,19 +105,19 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "relationName" of HasManyResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([], 'sourceName', 'targetName', v, 'foreignKey');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "foreignKey" parameter to be a non-empty string', async function () {
@@ -126,19 +126,19 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "foreignKey" of HasManyResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([], 'sourceName', 'targetName', 'relationName', v);
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the provided parameter "scope" to be an object', async function () {
@@ -147,7 +147,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The provided parameter "scope" of HasManyResolver.includeTo ' +
-            'should be an Object, but %v given.',
+            'should be an Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -159,10 +159,10 @@ describe('HasManyResolver', function () {
           'foreignKey',
           v,
         );
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
     });
 
     it('throws an error if a target model is not found', async function () {
@@ -726,7 +726,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of HasManyResolver.includePolymorphicTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -738,14 +738,14 @@ describe('HasManyResolver', function () {
           'foreignKey',
           'discriminator',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires elements of the "entities" parameter to be an Object', async function () {
@@ -755,7 +755,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of HasManyResolver.includePolymorphicTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -767,14 +767,14 @@ describe('HasManyResolver', function () {
           'foreignKey',
           'discriminator',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "sourceName" parameter to be a non-empty string', async function () {
@@ -783,7 +783,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "sourceName" of HasManyResolver.includePolymorphicTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -795,14 +795,14 @@ describe('HasManyResolver', function () {
           'foreignKey',
           'discriminator',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "targetName" parameter to be a non-empty string', async function () {
@@ -811,7 +811,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "targetName" of HasManyResolver.includePolymorphicTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -823,14 +823,14 @@ describe('HasManyResolver', function () {
           'foreignKey',
           'discriminator',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "relationName" parameter to be a non-empty string', async function () {
@@ -839,7 +839,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "relationName" of HasManyResolver.includePolymorphicTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -851,14 +851,14 @@ describe('HasManyResolver', function () {
           'foreignKey',
           'discriminator',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "foreignKey" parameter to be a non-empty string', async function () {
@@ -867,7 +867,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "foreignKey" of HasManyResolver.includePolymorphicTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -879,14 +879,14 @@ describe('HasManyResolver', function () {
           v,
           'discriminator',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "discriminator" parameter to be a non-empty string', async function () {
@@ -895,7 +895,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "discriminator" of HasManyResolver.includePolymorphicTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -907,14 +907,14 @@ describe('HasManyResolver', function () {
           'foreignKey',
           v,
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the provided parameter "scope" to be an object', async function () {
@@ -923,7 +923,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The provided parameter "scope" of HasManyResolver.includePolymorphicTo ' +
-            'should be an Object, but %v given.',
+            'should be an Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -936,10 +936,10 @@ describe('HasManyResolver', function () {
           'discriminator',
           v,
         );
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
     });
 
     it('throws an error if the given target model is not found', async function () {
@@ -1685,7 +1685,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of HasManyResolver.includePolymorphicByRelationName requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1696,14 +1696,14 @@ describe('HasManyResolver', function () {
           'relationName',
           'targetRelationName',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires elements of the "entities" parameter to be an Object', async function () {
@@ -1722,7 +1722,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of HasManyResolver.includePolymorphicTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1733,14 +1733,14 @@ describe('HasManyResolver', function () {
           'children',
           'parent',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "sourceName" parameter to be a non-empty string', async function () {
@@ -1749,7 +1749,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "sourceName" of HasManyResolver.includePolymorphicByRelationName requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1760,14 +1760,14 @@ describe('HasManyResolver', function () {
           'relationName',
           'targetRelationName',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "targetName" parameter to be a non-empty string', async function () {
@@ -1776,7 +1776,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "targetName" of HasManyResolver.includePolymorphicByRelationName requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1787,14 +1787,14 @@ describe('HasManyResolver', function () {
           'relationName',
           'targetRelationName',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "relationName" parameter to be a non-empty string', async function () {
@@ -1803,7 +1803,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "relationName" of HasManyResolver.includePolymorphicByRelationName requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1814,14 +1814,14 @@ describe('HasManyResolver', function () {
           v,
           'targetRelationName',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "targetRelationName" parameter to be a non-empty string', async function () {
@@ -1830,7 +1830,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The parameter "targetRelationName" of HasManyResolver.includePolymorphicByRelationName requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1841,14 +1841,14 @@ describe('HasManyResolver', function () {
           'relationName',
           v,
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the provided parameter "scope" to be an object', async function () {
@@ -1857,7 +1857,7 @@ describe('HasManyResolver', function () {
       const error = v =>
         format(
           'The provided parameter "scope" of HasManyResolver.includePolymorphicByRelationName ' +
-            'should be an Object, but %v given.',
+            'should be an Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1869,10 +1869,10 @@ describe('HasManyResolver', function () {
           'targetRelationName',
           v,
         );
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
     });
 
     it('throws an error if the given target model is not found', async function () {

src/relations/has-one-resolver.spec.js

@@ -14,7 +14,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of HasOneResolver.includeTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -25,14 +25,14 @@ describe('HasOneResolver', function () {
           'relationName',
           'foreignKey',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires elements of the "entities" parameter to be an Object', async function () {
@@ -42,19 +42,19 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of HasOneResolver.includeTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([v], 'source', 'target', 'relationName', 'foreignKey');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "sourceName" parameter to be a non-empty string', async function () {
@@ -63,19 +63,19 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "sourceName" of HasOneResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([], v, 'targetName', 'relationName', 'foreignKey');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "targetName" parameter to be a non-empty string', async function () {
@@ -84,19 +84,19 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "targetName" of HasOneResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([], 'sourceName', v, 'relationName', 'foreignKey');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "relationName" parameter to be a non-empty string', async function () {
@@ -105,19 +105,19 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "relationName" of HasOneResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([], 'sourceName', 'targetName', v, 'foreignKey');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "foreignKey" parameter to be a non-empty string', async function () {
@@ -126,19 +126,19 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "foreignKey" of HasOneResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([], 'sourceName', 'targetName', 'relationName', v);
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the provided parameter "scope" to be an object', async function () {
@@ -147,7 +147,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The provided parameter "scope" of HasOneResolver.includeTo ' +
-            'should be an Object, but %v given.',
+            'should be an Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -159,10 +159,10 @@ describe('HasOneResolver', function () {
           'foreignKey',
           v,
         );
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
     });
 
     it('throws an error if a target model is not found', async function () {
@@ -557,7 +557,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of HasOneResolver.includePolymorphicTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -569,14 +569,14 @@ describe('HasOneResolver', function () {
           'foreignKey',
           'discriminator',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires elements of the "entities" parameter to be an Object', async function () {
@@ -586,7 +586,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of HasOneResolver.includePolymorphicTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -598,14 +598,14 @@ describe('HasOneResolver', function () {
           'foreignKey',
           'discriminator',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "sourceName" parameter to be a non-empty string', async function () {
@@ -614,7 +614,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "sourceName" of HasOneResolver.includePolymorphicTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -626,14 +626,14 @@ describe('HasOneResolver', function () {
           'foreignKey',
           'discriminator',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "targetName" parameter to be a non-empty string', async function () {
@@ -642,7 +642,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "targetName" of HasOneResolver.includePolymorphicTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -654,14 +654,14 @@ describe('HasOneResolver', function () {
           'foreignKey',
           'discriminator',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "relationName" parameter to be a non-empty string', async function () {
@@ -670,7 +670,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "relationName" of HasOneResolver.includePolymorphicTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -682,14 +682,14 @@ describe('HasOneResolver', function () {
           'foreignKey',
           'discriminator',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "foreignKey" parameter to be a non-empty string', async function () {
@@ -698,7 +698,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "foreignKey" of HasOneResolver.includePolymorphicTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -710,14 +710,14 @@ describe('HasOneResolver', function () {
           v,
           'discriminator',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "discriminator" parameter to be a non-empty string', async function () {
@@ -726,7 +726,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "discriminator" of HasOneResolver.includePolymorphicTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -738,14 +738,14 @@ describe('HasOneResolver', function () {
           'foreignKey',
           v,
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the provided parameter "scope" to be an object', async function () {
@@ -754,7 +754,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The provided parameter "scope" of HasOneResolver.includePolymorphicTo ' +
-            'should be an Object, but %v given.',
+            'should be an Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -767,10 +767,10 @@ describe('HasOneResolver', function () {
           'discriminator',
           v,
         );
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
     });
 
     it('throws an error if the given target model is not found', async function () {
@@ -1307,7 +1307,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of HasOneResolver.includePolymorphicByRelationName requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1318,14 +1318,14 @@ describe('HasOneResolver', function () {
           'relationName',
           'targetRelationName',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires elements of the "entities" parameter to be an Object', async function () {
@@ -1344,7 +1344,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of HasOneResolver.includePolymorphicTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1355,14 +1355,14 @@ describe('HasOneResolver', function () {
           'child',
           'parent',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "sourceName" parameter to be a non-empty string', async function () {
@@ -1371,7 +1371,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "sourceName" of HasOneResolver.includePolymorphicByRelationName requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1382,14 +1382,14 @@ describe('HasOneResolver', function () {
           'relationName',
           'targetRelationName',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "targetName" parameter to be a non-empty string', async function () {
@@ -1398,7 +1398,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "targetName" of HasOneResolver.includePolymorphicByRelationName requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1409,14 +1409,14 @@ describe('HasOneResolver', function () {
           'relationName',
           'targetRelationName',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "relationName" parameter to be a non-empty string', async function () {
@@ -1425,7 +1425,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "relationName" of HasOneResolver.includePolymorphicByRelationName requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1436,14 +1436,14 @@ describe('HasOneResolver', function () {
           v,
           'targetRelationName',
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "targetRelationName" parameter to be a non-empty string', async function () {
@@ -1452,7 +1452,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The parameter "targetRelationName" of HasOneResolver.includePolymorphicByRelationName requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1463,14 +1463,14 @@ describe('HasOneResolver', function () {
           'relationName',
           v,
         );
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the provided parameter "scope" to be an object', async function () {
@@ -1479,7 +1479,7 @@ describe('HasOneResolver', function () {
       const error = v =>
         format(
           'The provided parameter "scope" of HasOneResolver.includePolymorphicByRelationName ' +
-            'should be an Object, but %v given.',
+            'should be an Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -1491,10 +1491,10 @@ describe('HasOneResolver', function () {
           'targetRelationName',
           v,
         );
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
     });
 
     it('throws an error if the given target model is not found', async function () {

src/relations/references-many-resolver.spec.js

@@ -14,19 +14,19 @@ describe('ReferencesManyResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of ReferencesManyResolver.includeTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo(v, 'sourceName', 'targetName', 'relationName');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires elements of the "entities" parameter to be an Object', async function () {
@@ -35,19 +35,19 @@ describe('ReferencesManyResolver', function () {
       const error = v =>
         format(
           'The parameter "entities" of ReferencesManyResolver.includeTo requires ' +
-            'an Array of Object, but %v given.',
+            'an Array of Object, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([v], 'sourceName', 'targetName', 'relationName');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "sourceName" parameter to be a non-empty string', async function () {
@@ -56,18 +56,18 @@ describe('ReferencesManyResolver', function () {
       const error = v =>
         format(
           'The parameter "sourceName" of ReferencesManyResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v => R.includeTo([], v, 'targetName', 'relationName');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "targetName" parameter to be a non-empty string', async function () {
@@ -76,18 +76,18 @@ describe('ReferencesManyResolver', function () {
       const error = v =>
         format(
           'The parameter "targetName" of ReferencesManyResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v => R.includeTo([], 'sourceName', v, 'relationName');
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the "relationName" parameter to be a non-empty string', async function () {
@@ -96,18 +96,18 @@ describe('ReferencesManyResolver', function () {
       const error = v =>
         format(
           'The parameter "relationName" of ReferencesManyResolver.includeTo requires ' +
-            'a non-empty String, but %v given.',
+            'a non-empty String, but %s given.',
           v,
         );
       const throwable = v => R.includeTo([], 'sourceName', 'targetName', v);
-      await expect(throwable('')).to.be.rejectedWith(error(''));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable(false)).to.be.rejectedWith(error(false));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
-      await expect(throwable(undefined)).to.be.rejectedWith(error(undefined));
-      await expect(throwable(null)).to.be.rejectedWith(error(null));
+      await expect(throwable('')).to.be.rejectedWith(error('""'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable(false)).to.be.rejectedWith(error('false'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
+      await expect(throwable(undefined)).to.be.rejectedWith(error('undefined'));
+      await expect(throwable(null)).to.be.rejectedWith(error('null'));
     });
 
     it('requires the provided parameter "foreignKey" to be a string', async function () {
@@ -116,15 +116,15 @@ describe('ReferencesManyResolver', function () {
       const error = v =>
         format(
           'The provided parameter "foreignKey" of ReferencesManyResolver.includeTo ' +
-            'should be a String, but %v given.',
+            'should be a String, but %s given.',
           v,
         );
       const throwable = v =>
         R.includeTo([], 'sourceName', 'targetName', 'relationName', v);
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
-      await expect(throwable({})).to.be.rejectedWith(error({}));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
+      await expect(throwable({})).to.be.rejectedWith(error('Object'));
     });
 
     it('requires the provided parameter "scope" to be an object', async function () {
@@ -133,7 +133,7 @@ describe('ReferencesManyResolver', function () {
       const error = v =>
         format(
           'The provided parameter "scope" of ReferencesManyResolver.includeTo ' +
-            'should be an Object, but %v given.',
+            'should be an Object, but %s given.',
           v,
         );
       const throwable = v =>
@@ -145,10 +145,10 @@ describe('ReferencesManyResolver', function () {
           undefined,
           v,
         );
-      await expect(throwable('str')).to.be.rejectedWith(error('str'));
-      await expect(throwable(10)).to.be.rejectedWith(error(10));
-      await expect(throwable(true)).to.be.rejectedWith(error(true));
-      await expect(throwable([])).to.be.rejectedWith(error([]));
+      await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
+      await expect(throwable(10)).to.be.rejectedWith(error('10'));
+      await expect(throwable(true)).to.be.rejectedWith(error('true'));
+      await expect(throwable([])).to.be.rejectedWith(error('Array'));
     });
 
     it('throws an error if the given target model is not found', async function () {

src/utils/exclude-object-keys.spec.js

@@ -37,13 +37,13 @@ describe('excludeObjectKeys', function () {
   it('throws an error for a non-object values', function () {
     const throwable = v => () => excludeObjectKeys(v, 'key');
     const error = v =>
-      format('Cannot exclude keys from a non-Object value, %v given.', v);
-    expect(throwable('string')).to.throw(error('string'));
-    expect(throwable(10)).to.throw(error(10));
-    expect(throwable(true)).to.throw(error(true));
-    expect(throwable(false)).to.throw(error(false));
-    expect(throwable([])).to.throw(error([]));
-    expect(throwable(null)).to.throw(error(null));
-    expect(throwable(undefined)).to.throw(error(undefined));
+      format('Cannot exclude keys from a non-Object value, %s given.', v);
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable(null)).to.throw(error('null'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
   });
 });