@e22m4u/js-repository 0.8.7 → 0.8.8

package/src/definition/model/properties/property-uniqueness-validator.spec.js

@@ -23,8 +23,7 @@ describe('PropertyUniquenessValidator', function () {
       const throwable = v => puv.validate(v, 'create', 'model', {});
       const error = v =>
         format(
-          'The parameter "countMethod" of the PropertyUniquenessValidator ' +
-            'must be a Function, but %s was given.',
+          'Parameter "countMethod" must be a Function, but %s was given.',
           v,
         );
       await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
@@ -58,8 +57,8 @@ describe('PropertyUniquenessValidator', function () {
       const throwable = v => puv.validate(() => 0, v, 'model', {});
       const error = v =>
         format(
-          'The parameter "methodName" of the PropertyUniquenessValidator ' +
-            'must be a non-empty String, but %s was given.',
+          'Parameter "methodName" must be a non-empty String, ' +
+            'but %s was given.',
           v,
         );
       await expect(throwable('')).to.be.rejectedWith(error('""'));
@@ -93,8 +92,7 @@ describe('PropertyUniquenessValidator', function () {
       const throwable = v => puv.validate(() => 0, 'create', v, {});
       const error = v =>
         format(
-          'The parameter "modelName" of the PropertyUniquenessValidator ' +
-            'must be a non-empty String, but %s was given.',
+          'Parameter "modelName" must be a non-empty String, but %s was given.',
           v,
         );
       await expect(throwable('')).to.be.rejectedWith(error('""'));
@@ -128,7 +126,7 @@ describe('PropertyUniquenessValidator', function () {
       const throwable = v => puv.validate(() => 0, 'create', 'model', v);
       const error = v =>
         format(
-          'The data of the model "model" should be an Object, but %s was given.',
+          'Data of the model "model" must be an Object, but %s was given.',
           v,
         );
       await expect(throwable('str')).to.be.rejectedWith(error('"str"'));
@@ -241,8 +239,7 @@ describe('PropertyUniquenessValidator', function () {
       const puv = dbs.getService(PropertyUniquenessValidator);
       const promise = puv.validate(() => 1, 'unsupported', 'model', {});
       await expect(promise).to.be.rejectedWith(
-        'The PropertyUniquenessValidator does not ' +
-          'support the adapter method "unsupported".',
+        'Adapter method "unsupported" is not supported.',
       );
     });
 
@@ -264,8 +261,8 @@ describe('PropertyUniquenessValidator', function () {
             foo: 'bar',
           });
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -341,8 +338,8 @@ describe('PropertyUniquenessValidator', function () {
             1,
           );
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -466,8 +463,8 @@ describe('PropertyUniquenessValidator', function () {
             foo: 'bar',
           });
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -795,8 +792,8 @@ describe('PropertyUniquenessValidator', function () {
           const puv = dbs.getService(PropertyUniquenessValidator);
           const promise = puv.validate(() => 1, 'patch', 'model', {foo: 'bar'});
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -815,7 +812,7 @@ describe('PropertyUniquenessValidator', function () {
           await puv.validate(() => 0, 'patch', 'model', {foo: 'bar'});
         });
 
-        it('invokes the "countMethod" for given properties which should be unique', async function () {
+        it('invokes the "countMethod" for given properties which must be unique', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -867,8 +864,8 @@ describe('PropertyUniquenessValidator', function () {
             baz: 'qux',
           });
           await expect(promise1).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
           await expect(promise2).not.to.be.rejected;
         });
@@ -895,8 +892,8 @@ describe('PropertyUniquenessValidator', function () {
             1,
           );
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -915,7 +912,7 @@ describe('PropertyUniquenessValidator', function () {
           await puv.validate(() => 0, 'patchById', 'model', {foo: 'bar'}, 1);
         });
 
-        it('invokes the "countMethod" for given properties which should be unique', async function () {
+        it('invokes the "countMethod" for given properties which must be unique', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -977,8 +974,8 @@ describe('PropertyUniquenessValidator', function () {
             baz: 'qux',
           });
           await expect(promise1).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
           await expect(promise2).not.to.be.rejected;
         });
@@ -1042,8 +1039,8 @@ describe('PropertyUniquenessValidator', function () {
             foo: 'bar',
           });
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -1119,8 +1116,8 @@ describe('PropertyUniquenessValidator', function () {
             1,
           );
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -1244,8 +1241,8 @@ describe('PropertyUniquenessValidator', function () {
             foo: 'bar',
           });
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -1573,8 +1570,8 @@ describe('PropertyUniquenessValidator', function () {
           const puv = dbs.getService(PropertyUniquenessValidator);
           const promise = puv.validate(() => 1, 'patch', 'model', {foo: 'bar'});
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -1593,7 +1590,7 @@ describe('PropertyUniquenessValidator', function () {
           await puv.validate(() => 0, 'patch', 'model', {foo: 'bar'});
         });
 
-        it('invokes the "countMethod" for given properties which should be unique', async function () {
+        it('invokes the "countMethod" for given properties which must be unique', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -1645,8 +1642,8 @@ describe('PropertyUniquenessValidator', function () {
             baz: 'qux',
           });
           await expect(promise1).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
           await expect(promise2).not.to.be.rejected;
         });
@@ -1673,8 +1670,8 @@ describe('PropertyUniquenessValidator', function () {
             1,
           );
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -1693,7 +1690,7 @@ describe('PropertyUniquenessValidator', function () {
           await puv.validate(() => 0, 'patchById', 'model', {foo: 'bar'}, 1);
         });
 
-        it('invokes the "countMethod" for given properties which should be unique', async function () {
+        it('invokes the "countMethod" for given properties which must be unique', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -1755,8 +1752,8 @@ describe('PropertyUniquenessValidator', function () {
             baz: 'qux',
           });
           await expect(promise1).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
           await expect(promise2).not.to.be.rejected;
         });
@@ -1820,8 +1817,8 @@ describe('PropertyUniquenessValidator', function () {
             foo: 'bar',
           });
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -1840,7 +1837,7 @@ describe('PropertyUniquenessValidator', function () {
           await puv.validate(() => 0, 'create', 'model', {foo: 'bar'});
         });
 
-        it('invokes the "countMethod" for given properties which should be unique', async function () {
+        it('invokes the "countMethod" for given properties which must be unique', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -2011,8 +2008,8 @@ describe('PropertyUniquenessValidator', function () {
             1,
           );
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -2031,7 +2028,7 @@ describe('PropertyUniquenessValidator', function () {
           await puv.validate(() => 0, 'replaceById', 'model', {foo: 'bar'}, 1);
         });
 
-        it('invokes the "countMethod" for given properties which should be unique', async function () {
+        it('invokes the "countMethod" for given properties which must be unique', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -2287,8 +2284,8 @@ describe('PropertyUniquenessValidator', function () {
             foo: 'bar',
           });
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -2307,7 +2304,7 @@ describe('PropertyUniquenessValidator', function () {
           await puv.validate(() => 0, 'replaceOrCreate', 'model', {foo: 'bar'});
         });
 
-        it('invokes the "countMethod" for given properties which should be unique', async function () {
+        it('invokes the "countMethod" for given properties which must be unique', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -2958,8 +2955,8 @@ describe('PropertyUniquenessValidator', function () {
           const puv = dbs.getService(PropertyUniquenessValidator);
           const promise = puv.validate(() => 1, 'patch', 'model', {foo: 'bar'});
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -2978,7 +2975,7 @@ describe('PropertyUniquenessValidator', function () {
           await puv.validate(() => 0, 'patch', 'model', {foo: 'bar'});
         });
 
-        it('invokes the "countMethod" for given properties which should be unique', async function () {
+        it('invokes the "countMethod" for given properties which must be unique', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -3030,8 +3027,8 @@ describe('PropertyUniquenessValidator', function () {
             baz: 'qux',
           });
           await expect(promise1).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
           await expect(promise2).not.to.be.rejected;
         });
@@ -3174,8 +3171,8 @@ describe('PropertyUniquenessValidator', function () {
             1,
           );
           await expect(promise).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
         });
 
@@ -3194,7 +3191,7 @@ describe('PropertyUniquenessValidator', function () {
           await puv.validate(() => 0, 'patchById', 'model', {foo: 'bar'}, 1);
         });
 
-        it('invokes the "countMethod" for given properties which should be unique', async function () {
+        it('invokes the "countMethod" for given properties which must be unique', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -3256,8 +3253,8 @@ describe('PropertyUniquenessValidator', function () {
             baz: 'qux',
           });
           await expect(promise1).to.be.rejectedWith(
-            'An existing document of the model "model" already has ' +
-              'the property "foo" with the value "bar" and should be unique.',
+            'Existing document of the model "model" already has ' +
+              'the property "foo" with the value "bar" and must be unique.',
           );
           await expect(promise2).not.to.be.rejected;
         });

package/src/definition/model/properties/required-property-validator.js

@@ -27,7 +27,7 @@ export class RequiredPropertyValidator extends Service {
       Array.isArray(modelData)
     ) {
       throw new InvalidArgumentError(
-        'Data of the model %v should be an Object, but %v was given.',
+        'Data of the model %v must be an Object, but %v was given.',
         modelName,
         modelData,
       );

package/src/definition/model/properties/required-property-validator.spec.js

@@ -35,7 +35,7 @@ describe('RequiredPropertyValidator', function () {
       const throwable = v => () => S.validate('model', v);
       const error = s =>
         format(
-          'Data of the model "model" should be an Object, but %s was given.',
+          'Data of the model "model" must be an Object, but %s was given.',
           s,
         );
       expect(throwable('str')).to.throw(error('"str"'));