@e22m4u/js-repository 0.0.33 → 0.0.35

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

@@ -16,16 +16,16 @@ export class SliceClauseTool extends Service {
   slice(entities, skip = undefined, limit = undefined) {
     if (!Array.isArray(entities))
       throw new InvalidArgumentError(
-        'A first argument of SliceClauseTool.slice ' +
+        'The first argument of SliceClauseTool.slice ' +
           'should be an Array, but %v given.',
         entities,
       );
-    if (skip && typeof skip !== 'number')
+    if (skip != null && typeof skip !== 'number')
       throw new InvalidArgumentError(
         'The provided option "skip" should be a Number, but %v given.',
         skip,
       );
-    if (limit && typeof limit !== 'number')
+    if (limit != null && typeof limit !== 'number')
       throw new InvalidArgumentError(
         'The provided option "limit" should be a Number, but %v given.',
         limit,
@@ -41,7 +41,7 @@ export class SliceClauseTool extends Service {
    * @param {number|undefined} skip
    */
   static validateSkipClause(skip) {
-    if (!skip) return;
+    if (skip == null) return;
     if (typeof skip !== 'number')
       throw new InvalidArgumentError(
         'The provided option "skip" should be a Number, but %v given.',
@@ -55,7 +55,7 @@ export class SliceClauseTool extends Service {
    * @param {number|undefined} limit
    */
   static validateLimitClause(limit) {
-    if (!limit) return;
+    if (limit == null) return;
     if (typeof limit !== 'number')
       throw new InvalidArgumentError(
         'The provided option "limit" should be a Number, but %v given.',

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

@@ -5,39 +5,100 @@ import {SliceClauseTool} from './slice-clause-tool.js';
 const S = new SliceClauseTool();
 
 describe('SliceClauseTool', function () {
-  describe('filter', function () {
-    it('does nothing if no clauses provided', function () {
+  describe('slice', function () {
+    it('requires the first argument to be an array', function () {
+      const throwable = v => () => S.slice(v);
+      const error = v =>
+        format(
+          'The first argument of SliceClauseTool.slice ' +
+            'should be an Array, but %s given.',
+          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('Object'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      expect(throwable([{foo: 'bar'}])()).to.be.eql([{foo: 'bar'}]);
+      expect(throwable([])()).to.be.eql([]);
+    });
+
+    it('requires the provided second argument to be a number', function () {
+      const items = [{foo: 'bar'}];
+      const throwable = v => () => S.slice(items, v);
+      const error = v =>
+        format(
+          'The provided option "skip" should be a Number, but %s given.',
+          v,
+        );
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      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(10)()).to.be.eql([]);
+      expect(throwable(0)()).to.be.eql(items);
+      expect(throwable(undefined)()).to.be.eql(items);
+      expect(throwable(null)()).to.be.eql(items);
+    });
+
+    it('requires the provided third argument to be a number', function () {
+      const items = [{foo: 'bar'}];
+      const throwable = v => () => S.slice(items, undefined, v);
+      const error = v =>
+        format(
+          'The provided option "limit" should be a Number, but %s given.',
+          v,
+        );
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      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(10)()).to.be.eql(items);
+      expect(throwable(0)()).to.be.eql(items);
+      expect(throwable(undefined)()).to.be.eql(items);
+      expect(throwable(null)()).to.be.eql(items);
+    });
+
+    it('does nothing if no "skip" and "limit" options provided', function () {
       const objects = [{id: 1}, {id: 2}, {id: 3}];
       const result = S.slice(objects);
       expect(result).to.be.eql(objects);
     });
 
-    it('does nothing if a given skip is zero', function () {
+    it('does nothing if the given "skip" option is zero', function () {
       const objects = [{id: 1}, {id: 2}, {id: 3}];
       const result = S.slice(objects, 0);
       expect(result).to.be.eql(objects);
     });
 
-    it('uses a given skip to exclude array elements from start', function () {
+    it('uses the given "skip" option to exclude array elements from start', function () {
       const objects = [{id: 1}, {id: 2}, {id: 3}];
       const result = S.slice(objects, 2);
       expect(result).to.have.length(1);
       expect(result[0]).to.be.eql(objects[2]);
     });
 
-    it('returns an empty array if skipping too much', function () {
+    it('returns an empty array when "skip" option overflows a size of the given array ', function () {
       const objects = [{id: 1}, {id: 2}, {id: 3}];
       const result = S.slice(objects, 10);
       expect(result).to.have.length(0);
     });
 
-    it('does nothing if a given limit is zero', function () {
+    it('does nothing if the given "limit" option is zero', function () {
       const objects = [{id: 1}, {id: 2}, {id: 3}];
       const result = S.slice(objects, undefined, 0);
       expect(result).to.be.eql(objects);
     });
 
-    it('uses a given limit to trim a given array', function () {
+    it('uses the given "limit" option to trim the given array', function () {
       const objects = [{id: 1}, {id: 2}, {id: 3}];
       const result = S.slice(objects, undefined, 2);
       expect(result).to.have.length(2);
@@ -45,73 +106,53 @@ describe('SliceClauseTool', function () {
       expect(result[1]).to.be.eql(objects[1]);
     });
 
-    it('able to combine a skip and a limit option together', function () {
+    it('uses the "skip" and "limit" options to slice the given array', function () {
       const objects = [{id: 1}, {id: 2}, {id: 3}];
       const result = S.slice(objects, 1, 1);
       expect(result).to.have.length(1);
       expect(result[0]).to.be.eql(objects[1]);
     });
-
-    it('throws an error if a first argument is not an array', function () {
-      const throwable = () => S.slice(10);
-      expect(throwable).to.throw(
-        'A first argument of SliceClauseTool.slice ' +
-          'should be an Array, but 10 given.',
-      );
-    });
-
-    it('throws an error if the given "skip" option is not a number', function () {
-      const throwable = () => S.slice([], 'invalid');
-      expect(throwable).to.throw(
-        'The provided option "skip" should be a Number, but "invalid" given.',
-      );
-    });
-
-    it('throws an error if the given "limit" option is not a number', function () {
-      const throwable = () => S.slice([], undefined, 'invalid');
-      expect(throwable).to.throw(
-        'The provided option "limit" should be a Number, but "invalid" given.',
-      );
-    });
   });
 
   describe('validateSkipClause', function () {
-    it('requires a number value or a falsy value', function () {
-      const validate = v => () => SliceClauseTool.validateSkipClause(v);
+    it('requires a number value', function () {
+      const throwable = v => () => SliceClauseTool.validateSkipClause(v);
       const error = v =>
         format(
           '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('Array'));
-      validate('')();
-      validate(false)();
-      validate(undefined)();
-      validate(null)();
-      validate(10)();
-      validate(0)();
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      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'));
+      throwable(10)();
+      throwable(0)();
+      throwable(undefined)();
+      throwable(null)();
     });
   });
 
   describe('validateLimitClause', function () {
     it('requires a number value or a falsy value', function () {
-      const validate = v => () => SliceClauseTool.validateLimitClause(v);
+      const throwable = v => () => SliceClauseTool.validateLimitClause(v);
       const error = v =>
         format(
           '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('Array'));
-      validate('')();
-      validate(false)();
-      validate(undefined)();
-      validate(null)();
-      validate(10)();
-      validate(0)();
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      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'));
+      throwable(10)();
+      throwable(0)();
+      throwable(undefined)();
+      throwable(null)();
     });
   });
 });

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

@@ -41,11 +41,11 @@ export class WhereClauseTool extends Service {
   filter(entities, where = undefined) {
     if (!Array.isArray(entities))
       throw new InvalidArgumentError(
-        'A first argument of WhereUtils.filter ' +
-          'should be an Array of Objects, but %v given.',
+        'The first argument of WhereClauseTool.filter should be ' +
+          'an Array of Object, but %v given.',
         entities,
       );
-    if (!where) return entities;
+    if (where == null) return entities;
     return entities.filter(this._createFilter(where));
   }
 
@@ -57,7 +57,7 @@ export class WhereClauseTool extends Service {
    */
   _createFilter(whereClause) {
     if (typeof whereClause === 'function') return whereClause;
-    if (typeof whereClause !== 'object')
+    if (typeof whereClause !== 'object' || Array.isArray(whereClause))
       throw new InvalidArgumentError(
         'The provided option "where" should be an Object, but %v given.',
         whereClause,
@@ -66,8 +66,8 @@ export class WhereClauseTool extends Service {
     return data => {
       if (typeof data !== 'object')
         throw new InvalidArgumentError(
-          'A first argument of WhereUtils.filter ' +
-            'should be an Array of Objects, but %v given.',
+          'The first argument of WhereClauseTool.filter should be ' +
+            'an Array of Object, but %v given.',
           data,
         );
       return keys.every(key => {
@@ -155,7 +155,7 @@ export class WhereClauseTool extends Service {
    * @param {WhereClause|undefined} clause
    */
   static validateWhereClause(clause) {
-    if (!clause) return;
+    if (clause == null || typeof clause === 'function') return;
     if (typeof clause !== 'object' || Array.isArray(clause))
       throw new InvalidArgumentError(
         'The provided option "where" should be an Object, but %v given.',

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

@@ -44,11 +44,56 @@ const OBJECTS = [
 
 describe('WhereClauseTool', function () {
   describe('filter', function () {
+    it('requires the first argument to be an array of objects', function () {
+      const throwable = v => () => S.filter(v, {});
+      const error = v =>
+        format(
+          'The first argument of WhereClauseTool.filter should be ' +
+            'an Array of Object, but %s given.',
+          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('Object'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      expect(throwable([{foo: 'bar'}])()).to.be.eql([{foo: 'bar'}]);
+      expect(throwable([])()).to.be.eql([]);
+    });
+
+    it('requires the second argument to be an object', function () {
+      const throwable = v => () => S.filter(OBJECTS, v);
+      const error = v =>
+        format(
+          'The provided option "where" should be an Object, but %s given.',
+          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('Array'));
+      expect(throwable({})()).to.be.eql(OBJECTS);
+      expect(throwable(undefined)()).to.be.eql(OBJECTS);
+      expect(throwable(null)()).to.be.eql(OBJECTS);
+    });
+
     it('returns the same array if no given condition', function () {
       const result = S.filter(OBJECTS);
       expect(result).to.be.eql(OBJECTS);
     });
 
+    it('returns the same array if the given clause object is empty', function () {
+      const result = S.filter(OBJECTS, {});
+      expect(result).to.be.eql(OBJECTS);
+    });
+
     it('returns a filtered array by matched properties', function () {
       const result = S.filter(OBJECTS, {surname: 'Smith', age: 21});
       expect(result).to.have.length(2);
@@ -56,7 +101,7 @@ describe('WhereClauseTool', function () {
       expect(result[1]).to.be.eql(OBJECTS[2]);
     });
 
-    it('the and operator requires each given condition to be met', function () {
+    it('the "and" operator requires each given condition to be met', function () {
       const result = S.filter(OBJECTS, {
         and: [{name: 'James'}, {age: 21}],
       });
@@ -64,7 +109,7 @@ describe('WhereClauseTool', function () {
       expect(result[0]).to.be.eql(OBJECTS[2]);
     });
 
-    it('the or operator requires one of a given condition to be met', function () {
+    it('the "or" operator requires one of a given condition to be met', function () {
       const result = S.filter(OBJECTS, {
         or: [{name: 'James'}, {age: 21}],
       });
@@ -101,13 +146,13 @@ describe('WhereClauseTool', function () {
       expect(result).to.be.empty;
     });
 
-    it('uses an "eq" operator to match equality', function () {
+    it('uses the "eq" operator to match equality', function () {
       const result = S.filter(OBJECTS, {name: {eq: 'John'}});
       expect(result).to.have.length(1);
       expect(result[0]).to.be.eql(OBJECTS[0]);
     });
 
-    it('uses a "neq" operator to match non-equality', function () {
+    it('uses the "neq" operator to match non-equality', function () {
       const result = S.filter(OBJECTS, {name: {neq: 'John'}});
       expect(result).to.have.length(3);
       expect(result[0]).to.be.eql(OBJECTS[1]);
@@ -115,21 +160,21 @@ describe('WhereClauseTool', function () {
       expect(result[2]).to.be.eql(OBJECTS[3]);
     });
 
-    it('uses a "neq" operator to match an empty array', function () {
+    it('uses the "neq" operator to match an empty array', function () {
       const result = S.filter(OBJECTS, {hobbies: {neq: 'bicycle'}});
       expect(result).to.have.length(2);
       expect(result[0]).to.be.eql(OBJECTS[1]);
       expect(result[1]).to.be.eql(OBJECTS[2]);
     });
 
-    it('uses a "gt" operator to compare values', function () {
+    it('uses the "gt" operator to compare values', function () {
       const result = S.filter(OBJECTS, {id: {gt: 2}});
       expect(result).to.have.length(2);
       expect(result[0]).to.be.eql(OBJECTS[2]);
       expect(result[1]).to.be.eql(OBJECTS[3]);
     });
 
-    it('uses a "gte" operator to compare values', function () {
+    it('uses the "gte" operator to compare values', function () {
       const result = S.filter(OBJECTS, {id: {gte: 2}});
       expect(result).to.have.length(3);
       expect(result[0]).to.be.eql(OBJECTS[1]);
@@ -137,14 +182,14 @@ describe('WhereClauseTool', function () {
       expect(result[2]).to.be.eql(OBJECTS[3]);
     });
 
-    it('uses a "lt" operator to compare values', function () {
+    it('uses the "lt" operator to compare values', function () {
       const result = S.filter(OBJECTS, {id: {lt: 3}});
       expect(result).to.have.length(2);
       expect(result[0]).to.be.eql(OBJECTS[0]);
       expect(result[1]).to.be.eql(OBJECTS[1]);
     });
 
-    it('uses a "lte" operator to compare values', function () {
+    it('uses the "lte" operator to compare values', function () {
       const result = S.filter(OBJECTS, {id: {lte: 3}});
       expect(result).to.have.length(3);
       expect(result[0]).to.be.eql(OBJECTS[0]);
@@ -152,28 +197,28 @@ describe('WhereClauseTool', function () {
       expect(result[2]).to.be.eql(OBJECTS[2]);
     });
 
-    it('uses a "inq" operator to compare values', function () {
+    it('uses the "inq" operator to compare values', function () {
       const result = S.filter(OBJECTS, {id: {inq: [2, 3]}});
       expect(result).to.have.length(2);
       expect(result[0]).to.be.eql(OBJECTS[1]);
       expect(result[1]).to.be.eql(OBJECTS[2]);
     });
 
-    it('uses a "nin" operator to compare values', function () {
+    it('uses the "nin" operator to compare values', function () {
       const result = S.filter(OBJECTS, {id: {nin: [2, 3]}});
       expect(result).to.have.length(2);
       expect(result[0]).to.be.eql(OBJECTS[0]);
       expect(result[1]).to.be.eql(OBJECTS[3]);
     });
 
-    it('uses a "between" operator to compare values', function () {
+    it('uses the "between" operator to compare values', function () {
       const result = S.filter(OBJECTS, {id: {between: [2, 3]}});
       expect(result).to.have.length(2);
       expect(result[0]).to.be.eql(OBJECTS[1]);
       expect(result[1]).to.be.eql(OBJECTS[2]);
     });
 
-    it('uses an "exists" operator to check existence', function () {
+    it('uses the "exists" operator to check existence', function () {
       const result = S.filter(OBJECTS, {nickname: {exists: true}});
       expect(result).to.have.length(3);
       expect(result[0]).to.be.eql(OBJECTS[0]);
@@ -181,19 +226,19 @@ describe('WhereClauseTool', function () {
       expect(result[2]).to.be.eql(OBJECTS[2]);
     });
 
-    it('uses an "exists" operator to check non-existence', function () {
+    it('uses the "exists" operator to check non-existence', function () {
       const result = S.filter(OBJECTS, {nickname: {exists: false}});
       expect(result).to.have.length(1);
       expect(result[0]).to.be.eql(OBJECTS[3]);
     });
 
-    it('uses a "like" operator to match by a substring', function () {
+    it('uses the "like" operator to match by a substring', function () {
       const result = S.filter(OBJECTS, {name: {like: 'liv'}});
       expect(result).to.have.length(1);
       expect(result[0]).to.be.eql(OBJECTS[3]);
     });
 
-    it('uses a "nlike" operator to exclude by a substring', function () {
+    it('uses the "nlike" operator to exclude by a substring', function () {
       const result = S.filter(OBJECTS, {name: {nlike: 'liv'}});
       expect(result).to.have.length(3);
       expect(result[0]).to.be.eql(OBJECTS[0]);
@@ -201,13 +246,13 @@ describe('WhereClauseTool', function () {
       expect(result[2]).to.be.eql(OBJECTS[2]);
     });
 
-    it('uses a "ilike" operator to case-insensitively matching by a substring', function () {
+    it('uses the "ilike" operator to case-insensitively matching by a substring', function () {
       const result = S.filter(OBJECTS, {name: {ilike: 'LIV'}});
       expect(result).to.have.length(1);
       expect(result[0]).to.be.eql(OBJECTS[3]);
     });
 
-    it('uses a "nilike" operator to exclude case-insensitively by a substring', function () {
+    it('uses the "nilike" operator to exclude case-insensitively by a substring', function () {
       const result = S.filter(OBJECTS, {name: {nilike: 'LIV'}});
       expect(result).to.have.length(3);
       expect(result[0]).to.be.eql(OBJECTS[0]);
@@ -215,66 +260,45 @@ describe('WhereClauseTool', function () {
       expect(result[2]).to.be.eql(OBJECTS[2]);
     });
 
-    it('uses a "regexp" operator to compare values', function () {
+    it('uses the "regexp" operator to compare values', function () {
       const result = S.filter(OBJECTS, {name: {regexp: '^Jam.*'}});
       expect(result).to.have.length(1);
       expect(result[0]).to.be.eql(OBJECTS[2]);
     });
 
-    it('uses a null to match an undefined and null value', function () {
+    it('uses null to match an undefined and null value', function () {
       const result = S.filter(OBJECTS, {nickname: null});
       expect(result).to.have.length(2);
       expect(result[0]).to.be.eql(OBJECTS[2]);
       expect(result[1]).to.be.eql(OBJECTS[3]);
     });
 
-    it('uses a given function to filter values', function () {
+    it('uses the given function to filter values', function () {
       const result = S.filter(OBJECTS, v => v.nickname === 'Flower');
       expect(result).to.have.length(1);
       expect(result[0]).to.be.eql(OBJECTS[1]);
     });
-
-    it('throws an error if a first argument is not an Array', function () {
-      const throwable = () => S.filter(10, {});
-      expect(throwable).to.throw(
-        'A first argument of WhereUtils.filter ' +
-          'should be an Array of Objects, but 10 given.',
-      );
-    });
-
-    it('throws an error if elements of a first argument is not an Object', function () {
-      const throwable = () => S.filter([10], {});
-      expect(throwable).to.throw(
-        'A first argument of WhereUtils.filter ' +
-          'should be an Array of Objects, but 10 given.',
-      );
-    });
-
-    it('throws an error if a provided second argument is not an Object', function () {
-      const throwable = () => S.filter([], 10);
-      expect(throwable).to.throw(
-        'The provided option "where" should be an Object, but 10 given.',
-      );
-    });
   });
 
   describe('validateWhereClause', function () {
-    it('requires an object value or a falsy value', function () {
-      const validate = v => () => WhereClauseTool.validateWhereClause(v);
+    it('requires the first argument to be an object or a function', function () {
+      const throwable = v => () => WhereClauseTool.validateWhereClause(v);
       const error = v =>
         format(
           '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('Array'));
-      validate('')();
-      validate(false)();
-      validate(undefined)();
-      validate(null)();
-      validate({})();
+      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('Array'));
+      throwable({foo: 'bar'})();
+      throwable({})();
+      throwable(undefined)();
+      throwable(null)();
     });
   });
 });

package/src/utils/select-object-keys.js

@@ -10,20 +10,20 @@ import {InvalidArgumentError} from '../errors/index.js';
 export function selectObjectKeys(obj, keys) {
   if (!obj || typeof obj !== 'object' || Array.isArray(obj))
     throw new InvalidArgumentError(
-      'A first argument of selectObjectKeys ' +
+      'The first argument of selectObjectKeys ' +
         'should be an Object, but %v given.',
       obj,
     );
   if (!Array.isArray(keys))
     throw new InvalidArgumentError(
-      'A second argument of selectObjectKeys ' +
+      'The second argument of selectObjectKeys ' +
         'should be an Array of String, but %v given.',
       keys,
     );
   keys.forEach(key => {
     if (typeof key !== 'string')
       throw new InvalidArgumentError(
-        'A second argument of selectObjectKeys ' +
+        'The second argument of selectObjectKeys ' +
           'should be an Array of String, but %v given.',
         key,
       );

package/src/utils/select-object-keys.spec.js

@@ -17,7 +17,7 @@ describe('selectObjectKeys', function () {
   it('throws an error if a given value is not an Object', function () {
     const throwable = () => selectObjectKeys(10, ['key']);
     expect(throwable).to.throw(
-      'A first argument of selectObjectKeys ' +
+      'The first argument of selectObjectKeys ' +
         'should be an Object, but 10 given.',
     );
   });
@@ -25,7 +25,7 @@ describe('selectObjectKeys', function () {
   it('throws an error if a given keys is not an Array', function () {
     const throwable = () => selectObjectKeys({});
     expect(throwable).to.throw(
-      'A second argument of selectObjectKeys ' +
+      'The second argument of selectObjectKeys ' +
         'should be an Array of String, but undefined given.',
     );
   });
@@ -33,7 +33,7 @@ describe('selectObjectKeys', function () {
   it('throws an error if a given keys is not an String', function () {
     const throwable = () => selectObjectKeys({}, [10]);
     expect(throwable).to.throw(
-      'A second argument of selectObjectKeys ' +
+      'The second argument of selectObjectKeys ' +
         'should be an Array of String, but 10 given.',
     );
   });