@e22m4u/js-repository 0.6.1 → 0.6.3

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

@@ -1,7 +1,7 @@
 import {Service} from '@e22m4u/js-service';
-import {getValueByPath} from '../utils/index.js';
 import {InvalidArgumentError} from '../errors/index.js';
 import {OperatorClauseTool} from './operator-clause-tool.js';
+import {getValueByPath, isDeepEqual, isPureObject} from '../utils/index.js';
 
 /**
  * Where clause tool.
@@ -75,8 +75,9 @@ export class WhereClauseTool extends Service {
           const andClause = whereClause[key];
           if (Array.isArray(andClause))
             return andClause.every(clause => this._createFilter(clause)(data));
-          // OrClause (recursion)
-        } else if (key === 'or' && key in whereClause) {
+        }
+        // OrClause (recursion)
+        else if (key === 'or' && key in whereClause) {
           const orClause = whereClause[key];
           if (Array.isArray(orClause))
             return orClause.some(clause => this._createFilter(clause)(data));
@@ -84,34 +85,6 @@ export class WhereClauseTool extends Service {
         // PropertiesClause (properties)
         const value = getValueByPath(data, key);
         const matcher = whereClause[key];
-        // Property value is an array.
-        if (Array.isArray(value)) {
-          // {neq: ...}
-          if (
-            typeof matcher === 'object' &&
-            matcher !== null &&
-            'neq' in matcher &&
-            matcher.neq !== undefined
-          ) {
-            // The following condition is for the case where
-            // we are querying with a neq filter, and when
-            // the value is an empty array ([]).
-            if (value.length === 0) return true;
-            // The neq operator requires each element
-            // of the array to be excluded.
-            return value.every((el, index) => {
-              const where = {};
-              where[index] = matcher;
-              return this._createFilter(where)({...value});
-            });
-          }
-          // Requires one of an array elements to be match.
-          return value.some((el, index) => {
-            const where = {};
-            where[index] = matcher;
-            return this._createFilter(where)({...value});
-          });
-        }
         // Test property value.
         if (this._test(matcher, value)) return true;
       });
@@ -126,30 +99,55 @@ export class WhereClauseTool extends Service {
    * @returns {boolean}
    */
   _test(example, value) {
-    // Test null.
+    // прямое сравнение
+    if (example === value) {
+      return true;
+    }
+    // условием является null
     if (example === null) {
       return value === null;
     }
-    // Test undefined.
+    // условием является undefined
     if (example === undefined) {
       return value === undefined;
     }
-    // Test RegExp.
-    // noinspection ALL
+    // условием является регулярное выражение
     if (example instanceof RegExp) {
-      if (typeof value === 'string') return !!value.match(example);
+      if (typeof value === 'string') {
+        return example.test(value);
+      }
+      // если значением является массив,
+      // то проверяется каждый элемент
+      if (Array.isArray(value)) {
+        return value.some(el => typeof el === 'string' && example.test(el));
+      }
       return false;
     }
-    // Operator clause.
-    if (typeof example === 'object') {
+    // условием является простой объект
+    if (isPureObject(example)) {
       const operatorsTest = this.getService(OperatorClauseTool).testAll(
         example,
         value,
       );
-      if (operatorsTest !== undefined) return operatorsTest;
+      if (operatorsTest !== undefined) {
+        // особая логика для neq с массивами
+        // {hobbies: {neq: 'yoga'}}
+        //   должно вернуть true для
+        // ['bicycle', 'meditation']
+        if ('neq' in example && Array.isArray(value)) {
+          return !value.some(el => isDeepEqual(el, example.neq));
+        }
+        return operatorsTest;
+      }
+    }
+    // значением является массив
+    if (Array.isArray(value)) {
+      // если один из элементов массива соответствует
+      // поиску, то возвращается true
+      const isElementMatched = value.some(el => isDeepEqual(el, example));
+      if (isElementMatched) return true;
     }
-    // Not strict equality.
-    return example == value;
+    return isDeepEqual(example, value);
   }
 
   /**

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

@@ -13,6 +13,7 @@ const OBJECTS = [
     hobbies: ['bicycle', 'yoga'],
     nickname: 'Spear',
     birthdate: '2002-04-14',
+    address: {city: 'New York', street: '5th Avenue'},
   },
   {
     id: 2,
@@ -22,6 +23,7 @@ const OBJECTS = [
     hobbies: ['yoga', 'meditation'],
     nickname: 'Flower',
     birthdate: '2002-01-12',
+    address: {city: 'London', street: 'Baker Street'},
   },
   {
     id: 3,
@@ -31,6 +33,7 @@ const OBJECTS = [
     hobbies: [],
     nickname: null,
     birthdate: '2002-03-01',
+    address: {city: 'Paris', street: 'Champs-Élysées'},
   },
   {
     id: 4,
@@ -39,6 +42,18 @@ const OBJECTS = [
     age: 32,
     hobbies: ['bicycle'],
     birthdate: '1991-06-24',
+    // нет nickname
+    address: {city: 'New York', street: 'Wall Street'},
+  },
+  {
+    id: 5,
+    name: 'Peter',
+    surname: 'Jones',
+    age: 45,
+    hobbies: ['fishing'],
+    birthdate: '1978-11-05',
+    // нет nickname
+    address: {city: 'New York', street: '5th Avenue'},
   },
 ];
 
@@ -154,32 +169,36 @@ describe('WhereClauseTool', 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).to.have.length(4);
       expect(result[0]).to.be.eql(OBJECTS[1]);
       expect(result[1]).to.be.eql(OBJECTS[2]);
       expect(result[2]).to.be.eql(OBJECTS[3]);
+      expect(result[3]).to.be.eql(OBJECTS[4]);
     });
 
     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).to.have.length(3);
       expect(result[0]).to.be.eql(OBJECTS[1]);
       expect(result[1]).to.be.eql(OBJECTS[2]);
+      expect(result[2]).to.be.eql(OBJECTS[4]);
     });
 
     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).to.have.length(3);
       expect(result[0]).to.be.eql(OBJECTS[2]);
       expect(result[1]).to.be.eql(OBJECTS[3]);
+      expect(result[2]).to.be.eql(OBJECTS[4]);
     });
 
     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).to.have.length(4);
       expect(result[0]).to.be.eql(OBJECTS[1]);
       expect(result[1]).to.be.eql(OBJECTS[2]);
       expect(result[2]).to.be.eql(OBJECTS[3]);
+      expect(result[3]).to.be.eql(OBJECTS[4]);
     });
 
     it('uses the "lt" operator to compare values', function () {
@@ -206,9 +225,10 @@ describe('WhereClauseTool', 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).to.have.length(3);
       expect(result[0]).to.be.eql(OBJECTS[0]);
       expect(result[1]).to.be.eql(OBJECTS[3]);
+      expect(result[2]).to.be.eql(OBJECTS[4]);
     });
 
     it('uses the "between" operator to compare values', function () {
@@ -228,36 +248,39 @@ describe('WhereClauseTool', 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).to.have.length(2);
       expect(result[0]).to.be.eql(OBJECTS[3]);
+      expect(result[1]).to.be.eql(OBJECTS[4]);
     });
 
     it('uses the "like" operator to match by a substring', function () {
-      const result = S.filter(OBJECTS, {name: {like: 'liv'}});
+      const result = S.filter(OBJECTS, {name: {like: '%liv%'}});
       expect(result).to.have.length(1);
       expect(result[0]).to.be.eql(OBJECTS[3]);
     });
 
     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);
+      const result = S.filter(OBJECTS, {name: {nlike: '%liv%'}});
+      expect(result).to.have.length(4);
       expect(result[0]).to.be.eql(OBJECTS[0]);
       expect(result[1]).to.be.eql(OBJECTS[1]);
       expect(result[2]).to.be.eql(OBJECTS[2]);
+      expect(result[3]).to.be.eql(OBJECTS[4]);
     });
 
     it('uses the "ilike" operator to case-insensitively matching by a substring', function () {
-      const result = S.filter(OBJECTS, {name: {ilike: 'LIV'}});
+      const result = S.filter(OBJECTS, {name: {ilike: '%LIV%'}});
       expect(result).to.have.length(1);
       expect(result[0]).to.be.eql(OBJECTS[3]);
     });
 
     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);
+      const result = S.filter(OBJECTS, {name: {nilike: '%LIV%'}});
+      expect(result).to.have.length(4);
       expect(result[0]).to.be.eql(OBJECTS[0]);
       expect(result[1]).to.be.eql(OBJECTS[1]);
       expect(result[2]).to.be.eql(OBJECTS[2]);
+      expect(result[3]).to.be.eql(OBJECTS[4]);
     });
 
     it('uses the "regexp" operator to compare values', function () {
@@ -274,8 +297,95 @@ describe('WhereClauseTool', function () {
 
     it('does not use undefined to match a null value', function () {
       const result = S.filter(OBJECTS, {nickname: undefined});
-      expect(result).to.have.length(1);
+      expect(result).to.have.length(2);
       expect(result[0]).to.be.eql(OBJECTS[3]);
+      expect(result[1]).to.be.eql(OBJECTS[4]);
+    });
+
+    describe('advanced matching', function () {
+      it('combines multiple operators for one field using "and"', function () {
+        const result = S.filter(OBJECTS, {
+          and: [{age: {gt: 20}}, {age: {lt: 30}}],
+        });
+        expect(result).to.have.length(3);
+        expect(result.map(o => o.id)).to.eql([1, 2, 3]);
+      });
+
+      it('combines multiple operators for one field implicitly', function () {
+        const result = S.filter(OBJECTS, {age: {gt: 20, lt: 30}});
+        expect(result).to.have.length(3);
+        expect(result.map(o => o.id)).to.eql([1, 2, 3]);
+      });
+
+      it('uses dot notation to query nested objects', function () {
+        const result = S.filter(OBJECTS, {'address.city': 'New York'});
+        expect(result).to.have.length(3);
+        expect(result.map(o => o.id)).to.eql([1, 4, 5]);
+      });
+
+      it('uses dot notation combined with operators', function () {
+        const result = S.filter(OBJECTS, {
+          'address.street': {like: '%Avenue%'},
+        });
+        expect(result).to.have.length(2);
+        expect(result.map(o => o.id)).to.eql([1, 5]);
+      });
+
+      it('matches an object by exact deep equality', function () {
+        const result = S.filter(OBJECTS, {
+          address: {city: 'New York', street: '5th Avenue'},
+        });
+        expect(result).to.have.length(2);
+        expect(result.map(o => o.id)).to.eql([1, 5]);
+      });
+
+      it('does not match an object if it has extra properties', function () {
+        const result = S.filter(OBJECTS, {
+          address: {city: 'New York'},
+        });
+        expect(result).to.have.length(0);
+      });
+
+      it('does match an object if property order is different', function () {
+        const result = S.filter(OBJECTS, {
+          address: {street: '5th Avenue', city: 'New York'},
+        });
+        expect(result).to.have.length(2);
+        expect(result[0].id).to.equal(1);
+        expect(result[1].id).to.equal(5);
+      });
+
+      it('matches an array by exact deep equality', function () {
+        const result = S.filter(OBJECTS, {
+          hobbies: ['bicycle', 'yoga'],
+        });
+        expect(result).to.have.length(1);
+        expect(result[0].id).to.equal(1);
+      });
+
+      it('does not match an array if order is different', function () {
+        const result = S.filter(OBJECTS, {
+          hobbies: ['yoga', 'bicycle'],
+        });
+        expect(result).to.have.length(0);
+      });
+
+      it('does not match an array if it contains extra items', function () {
+        const result = S.filter(OBJECTS, {
+          hobbies: ['bicycle'],
+        });
+        // Найдет только объект с id: 4, так как у него hobbies: ['bicycle']
+        expect(result).to.have.length(1);
+        expect(result[0].id).to.equal(4);
+      });
+
+      it('correctly combines multiple operators with dot notation in an "and" clause', function () {
+        const result = S.filter(OBJECTS, {
+          and: [{'address.city': 'New York'}, {age: {gt: 30}}],
+        });
+        expect(result).to.have.length(2);
+        expect(result.map(o => o.id)).to.eql([4, 5]);
+      });
     });
   });
 

package/src/utils/index.d.ts

@@ -6,6 +6,7 @@ export * from './singularize.js';
 export * from './is-deep-equal.js';
 export * from './get-ctor-name.js';
 export * from './is-pure-object.js';
+export * from './like-to-regexp.js';
 export * from './string-to-regexp.js';
 export * from './get-value-by-path.js';
 export * from './transform-promise.js';

package/src/utils/index.js

@@ -6,6 +6,7 @@ export * from './singularize.js';
 export * from './is-deep-equal.js';
 export * from './get-ctor-name.js';
 export * from './is-pure-object.js';
+export * from './like-to-regexp.js';
 export * from './string-to-regexp.js';
 export * from './get-value-by-path.js';
 export * from './transform-promise.js';

package/src/utils/like-to-regexp.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Преобразует SQL LIKE-шаблон в объект RegExp.
+ *
+ * Экранирует специальные символы регулярных выражений,
+ * чтобы они обрабатывались как обычные символы, и преобразует
+ * SQL wildcards (% и _) в их эквиваленты в регулярных выражениях.
+ *
+ * @param pattern
+ * @param isCaseInsensitive
+ */
+export function likeToRegexp(
+  pattern: string,
+  isCaseInsensitive?: boolean,
+): RegExp;

package/src/utils/like-to-regexp.js

@@ -0,0 +1,57 @@
+import {InvalidArgumentError} from '../errors/index.js';
+
+/**
+ * Преобразует SQL LIKE-шаблон в объект RegExp.
+ *
+ * Экранирует специальные символы регулярных выражений,
+ * чтобы они обрабатывались как обычные символы, и преобразует
+ * SQL wildcards (% и _) в их эквиваленты в регулярных выражениях.
+ *
+ * @param {string} pattern
+ * @param {boolean} isCaseInsensitive
+ * @returns {RegExp}
+ */
+export function likeToRegexp(pattern, isCaseInsensitive = false) {
+  if (typeof pattern !== 'string') {
+    throw new InvalidArgumentError(
+      'The first argument of `likeToRegexp` ' +
+        'should be a String, but %v was given.',
+      pattern,
+    );
+  }
+  // символы, которые имеют специальное значение
+  // в RegExp и должны быть экранированы
+  const regexSpecials = '-[]{}()*+?.\\^$|';
+  let regexString = '';
+  let isEscaping = false;
+  // экранирование
+  for (const char of pattern) {
+    if (isEscaping) {
+      // предыдущий символ был '\', значит текущий символ - литерал
+      regexString += regexSpecials.includes(char) ? `\\${char}` : char;
+      isEscaping = false;
+    } else if (char === '\\') {
+      // символ экранирования, следующий символ будет литералом
+      isEscaping = true;
+    } else if (char === '%') {
+      // SQL wildcard: любое количество любых символов
+      regexString += '.*';
+    } else if (char === '_') {
+      // SQL wildcard: ровно один любой символ
+      regexString += '.';
+    } else if (regexSpecials.includes(char)) {
+      // экранирование других специальных символов RegExp
+      regexString += `\\${char}`;
+    } else {
+      // обычный символ
+      regexString += char;
+    }
+  }
+  // если строка заканчивается на экранирующий символ,
+  // считаем его литералом.
+  if (isEscaping) {
+    regexString += '\\\\';
+  }
+  const flags = isCaseInsensitive ? 'i' : '';
+  return new RegExp(`^${regexString}$`, flags);
+}

package/src/utils/like-to-regexp.spec.js

@@ -0,0 +1,143 @@
+import {expect} from 'chai';
+import {likeToRegexp} from './like-to-regexp.js';
+
+describe('likeToRegexp', function () {
+  it('throws an error if the pattern is not a string', function () {
+    const error = v =>
+      'The first argument of `likeToRegexp` ' +
+      `should be a String, but ${v} was given.`;
+    expect(() => likeToRegexp(123)).to.throw(error('123'));
+    expect(() => likeToRegexp(null)).to.throw(error('null'));
+    expect(() => likeToRegexp({})).to.throw(error('Object'));
+  });
+
+  describe('basic wildcards', function () {
+    it('should handle "%" as zero or more characters', function () {
+      const re = likeToRegexp('he%o');
+      expect(re.test('hello')).to.be.true;
+      expect(re.test('heo')).to.be.true;
+      expect(re.test('hexxxxo')).to.be.true;
+      expect(re.test('ahello')).to.be.false;
+      expect(re.test('hellob')).to.be.false;
+    });
+
+    it('should handle "_" as exactly one character', function () {
+      const re = likeToRegexp('he_lo');
+      expect(re.test('hello')).to.be.true;
+      expect(re.test('healo')).to.be.true;
+      expect(re.test('he_lo')).to.be.true;
+      expect(re.test('helo')).to.be.false;
+      expect(re.test('helllo')).to.be.false;
+    });
+
+    it('should handle multiple wildcards', function () {
+      const re = likeToRegexp('%_world%');
+      expect(re.test('hello_world_today')).to.be.true;
+      expect(re.test('a_world')).to.be.true;
+      expect(re.test('no_match')).to.be.false;
+    });
+  });
+
+  describe('case sensitivity', function () {
+    it('should be case-sensitive by default', function () {
+      const re = likeToRegexp('Hello%');
+      expect(re.test('Hello World')).to.be.true;
+      expect(re.test('hello World')).to.be.false;
+    });
+
+    it('should be case-insensitive when specified', function () {
+      const re = likeToRegexp('Hello%', true);
+      expect(re.test('Hello World')).to.be.true;
+      expect(re.test('hello World')).to.be.true;
+      expect(re.test('HELLO WORLD')).to.be.true;
+    });
+  });
+
+  describe('escaping', function () {
+    it('should handle escaped "%" as a literal character', function () {
+      const re = likeToRegexp('100\\%');
+      expect(re.test('100%')).to.be.true;
+      expect(re.test('100_')).to.be.false;
+    });
+
+    it('should handle escaped "_" as a literal character', function () {
+      const re = likeToRegexp('file\\_name');
+      expect(re.test('file_name')).to.be.true;
+      expect(re.test('filename')).to.be.false;
+    });
+
+    it('should handle escaped backslash as a literal backslash', function () {
+      const re = likeToRegexp('path\\\\to\\\\file');
+      expect(re.test('path\\to\\file')).to.be.true;
+      expect(re.test('pathtofile')).to.be.false;
+    });
+
+    it('should handle a trailing backslash as a literal backslash', function () {
+      const re = likeToRegexp('path\\');
+      expect(re.test('path\\')).to.be.true;
+      expect(re.test('path')).to.be.false;
+    });
+
+    it('should handle mixed escaping and wildcards', function () {
+      const re = likeToRegexp('%file\\_%.docx');
+      expect(re.test('my_awesome_file_v1.docx')).to.be.true;
+      expect(re.test('my_awesome_file-v1.docx')).to.be.false;
+    });
+  });
+
+  describe('escaping RegExp special character', function () {
+    it('should escape dots "." as literal dots', function () {
+      const re = likeToRegexp('v1.0');
+      expect(re.test('v1.0')).to.be.true;
+      expect(re.test('v1_0')).to.be.false;
+    });
+
+    it('should escape parentheses "()" as literals', function () {
+      const re = likeToRegexp('file(1)');
+      expect(re.test('file(1)')).to.be.true;
+      expect(re.test('file1')).to.be.false;
+    });
+
+    it('should escape plus signs "+"', function () {
+      const re = likeToRegexp('C++');
+      expect(re.test('C++')).to.be.true;
+      expect(re.test('C+')).to.be.false;
+    });
+
+    it('should escape question marks "?"', function () {
+      const re = likeToRegexp('Are you sure?');
+      expect(re.test('Are you sure?')).to.be.true;
+      expect(re.test('Are you sure')).to.be.false;
+    });
+
+    it('should escape curly braces "{}"', function () {
+      const re = likeToRegexp('{id}');
+      expect(re.test('{id}')).to.be.true;
+      expect(re.test('id')).to.be.false;
+    });
+
+    it('should handle a complex string with multiple special characters', function () {
+      const pattern = 'docs\\(v1.0\\)/%.txt+';
+      const re = likeToRegexp(pattern);
+      expect(re.test('docs(v1.0)/document_v2.txt+')).to.be.true;
+      expect(re.test('docs(v1.0)/document_v2.txt')).to.be.false;
+    });
+  });
+
+  describe('full pattern matching', function () {
+    it('should match the entire string, not just a part of it', function () {
+      const re = likeToRegexp('world');
+      expect(re.test('hello world')).to.be.false;
+      expect(re.test('world today')).to.be.false;
+      expect(re.test('world')).to.be.true;
+    });
+
+    it('should match the entire string when using wildcards at boundaries', function () {
+      const re = likeToRegexp('%world%');
+      expect(re.test('hello world')).to.be.true;
+      expect(re.test('world today')).to.be.true;
+      expect(re.test('hello world today')).to.be.true;
+      expect(re.test('world')).to.be.true;
+    });
+  });
+});

package/src/utils/string-to-regexp.js

@@ -9,14 +9,5 @@ export function stringToRegexp(pattern, flags = undefined) {
   if (pattern instanceof RegExp) {
     return new RegExp(pattern, flags);
   }
-  let regex = '';
-  for (let i = 0, n = pattern.length; i < n; i++) {
-    const char = pattern.charAt(i);
-    if (char === '%') {
-      regex += '.*';
-    } else {
-      regex += char;
-    }
-  }
-  return new RegExp(regex, flags);
+  return new RegExp(pattern, flags);
 }

package/src/utils/string-to-regexp.spec.js

@@ -2,34 +2,37 @@ import {expect} from 'chai';
 import {stringToRegexp} from './string-to-regexp.js';
 
 describe('stringToRegexp', function () {
-  it('returns RegExp from a given string', function () {
+  it('should return RegExp from a given string', function () {
     expect(stringToRegexp('value').test('value')).to.be.true;
     expect(stringToRegexp('val.+').test('value')).to.be.true;
-    expect(stringToRegexp('%alu%').test('value')).to.be.true;
     expect(stringToRegexp('val*').test('value')).to.be.true;
   });
 
-  it('uses case-sensitive mode by default', function () {
+  it('should uses case-sensitive mode by default', function () {
     expect(stringToRegexp('value').test('VALUE')).to.be.false;
     expect(stringToRegexp('val.+').test('VALUE')).to.be.false;
     expect(stringToRegexp('%alu%').test('VALUE')).to.be.false;
     expect(stringToRegexp('val*').test('VALUE')).to.be.false;
   });
 
-  it('uses given flags in a new RegExp', function () {
+  it('should uses given flags in a new RegExp', function () {
     expect(stringToRegexp('value', 'i').test('VALUE')).to.be.true;
     expect(stringToRegexp('val.+', 'i').test('VALUE')).to.be.true;
-    expect(stringToRegexp('%alu%', 'i').test('VALUE')).to.be.true;
     expect(stringToRegexp('val*', 'i').test('VALUE')).to.be.true;
   });
 
-  it('returns RegExp from a given RegExp', function () {
+  it('should return RegExp from a given RegExp', function () {
     const regExp = new RegExp('value');
     expect(stringToRegexp(regExp).test('value')).to.be.true;
   });
 
-  it('overrides flags of a given RegExp', function () {
+  it('should overrides flags of a given RegExp', function () {
     const regExp = new RegExp('value');
     expect(stringToRegexp(regExp, 'i').test('VALUE')).to.be.true;
   });
+
+  it('should not replace "%" and "_" symbols as SQL-like wildcard', function () {
+    const res = stringToRegexp('%alu_');
+    expect(res).to.be.eql(/%alu_/);
+  });
 });