@e22m4u/js-repository 0.0.34 → 0.0.35

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.',
     );
   });