Add more unit tests

Author: duydvu

src/operations.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from '@jest/globals';
-import { parseExpression } from './operations';
+import { parseExpression, parseOp } from './operations';
 
 describe('Test parseExpression', () => {
   test('INT op', () => {
@@ -57,4 +57,210 @@ describe('Test parseExpression', () => {
     expect(parseExpression('NULL(a)', { a: {} })).toBe(false);
     expect(parseExpression('NULL(a)', { a: [] })).toBe(false);
   });
+
+  test('NOT_NULL op', () => {
+    expect(parseExpression('NOT_NULL(a)', { a: null })).toBe(false);
+    expect(parseExpression('NOT_NULL(a)', { a: undefined })).toBe(true);
+    expect(parseExpression('NOT_NULL(a)', { a: 0 })).toBe(true);
+    expect(parseExpression('NOT_NULL(a)', { a: '' })).toBe(true);
+    expect(parseExpression('NOT_NULL(a)', { a: {} })).toBe(true);
+    expect(parseExpression('NOT_NULL(a)', { a: [] })).toBe(true);
+  });
+
+  test('NOT op', () => {
+    expect(parseExpression('NOT(a)', { a: false })).toBe(true);
+    expect(parseExpression('NOT(a)', { a: true })).toBe(false);
+  });
+
+  test('STR_LEN op', () => {
+    expect(parseExpression('STR_LEN(a)', { a: '123' })).toBe(3);
+    expect(parseExpression('STR_LEN(a)', { a: 1 })).toBe(1);
+  });
+
+  test('LOWER op', () => {
+    expect(parseExpression('LOWER(a)', { a: 'ABCDEF' })).toBe('abcdef');
+  });
+
+  test('UPPER op', () => {
+    expect(parseExpression('UPPER(a)', { a: 'abcdef' })).toBe('ABCDEF');
+  });
+
+  test('TRIM op', () => {
+    expect(parseExpression('TRIM(a)', { a: '   abc  def   ' })).toBe('abc  def');
+  });
+
+  test('ARRAY_LEN op', () => {
+    expect(parseExpression('ARRAY_LEN(a)', { a: [1, 2, 3] })).toBe(3);
+    expect(parseExpression('ARRAY_LEN(a)', { a: 1 })).toBe(0);
+  });
+
+  test('SUM op', () => {
+    expect(parseExpression('SUM(a, b)', { a: 1, b: 2 })).toBe(3);
+  });
+
+  test('SUBTRACT op', () => {
+    expect(parseExpression('SUBTRACT(a, b)', { a: 5, b: 2 })).toBe(3);
+  });
+
+  test('MULTIPLY op', () => {
+    expect(parseExpression('MULTIPLY(a, b)', { a: 5, b: 2 })).toBe(10);
+  });
+
+  test('DIVIDE op', () => {
+    expect(parseExpression('DIVIDE(a, b)', { a: 5, b: 2 })).toBe(2.5);
+  });
+
+  test('REMAINDER op', () => {
+    expect(parseExpression('REMAINDER(a, b)', { a: 5, b: 2 })).toBe(1);
+  });
+
+  test('ROUND op', () => {
+    expect(parseExpression('ROUND(a, b)', { a: 5, b: 2 })).toBe('5.00');
+  });
+
+  test('MAX op', () => {
+    expect(parseExpression('MAX(a, b)', { a: 5, b: 2 })).toBe(5);
+  });
+
+  test('MIN op', () => {
+    expect(parseExpression('MIN(a, b)', { a: 5, b: 2 })).toBe(2);
+  });
+
+  test('POWER op', () => {
+    expect(parseExpression('POWER(a, b)', { a: 5, b: 2 })).toBe(25);
+  });
+
+  test('CONCAT op', () => {
+    expect(parseExpression('CONCAT(a, b)', { a: '123', b: '456' })).toBe('123456');
+  });
+
+  test('LEFT op', () => {
+    expect(parseExpression('LEFT(a, b)', { a: '123456', b: 3 })).toBe('123');
+  });
+
+  test('RIGHT op', () => {
+    expect(parseExpression('RIGHT(a, b)', { a: '123456', b: 3 })).toBe('456');
+  });
+
+  test('EQUAL op', () => {
+    expect(parseExpression('EQUAL(a, b)', { a: 1, b: 1 })).toBe(true);
+    expect(parseExpression('EQUAL(a, b)', { a: 1, b: '1' })).toBe(false);
+  });
+
+  test('NOT_EQUAL op', () => {
+    expect(parseExpression('NOT_EQUAL(a, b)', { a: 1, b: 1 })).toBe(false);
+    expect(parseExpression('NOT_EQUAL(a, b)', { a: 1, b: '1' })).toBe(true);
+  });
+
+  test('GT op', () => {
+    expect(parseExpression('GT(a, b)', { a: 1, b: 2 })).toBe(false);
+    expect(parseExpression('GT(a, b)', { a: 1, b: 1 })).toBe(false);
+    expect(parseExpression('GT(a, b)', { a: 2, b: 1 })).toBe(true);
+  });
+
+  test('GTE op', () => {
+    expect(parseExpression('GTE(a, b)', { a: 1, b: 2 })).toBe(false);
+    expect(parseExpression('GTE(a, b)', { a: 1, b: 1 })).toBe(true);
+    expect(parseExpression('GTE(a, b)', { a: 2, b: 1 })).toBe(true);
+  });
+
+  test('LT op', () => {
+    expect(parseExpression('LT(a, b)', { a: 1, b: 2 })).toBe(true);
+    expect(parseExpression('LT(a, b)', { a: 1, b: 1 })).toBe(false);
+    expect(parseExpression('LT(a, b)', { a: 2, b: 1 })).toBe(false);
+  });
+
+  test('LTE op', () => {
+    expect(parseExpression('LTE(a, b)', { a: 1, b: 2 })).toBe(true);
+    expect(parseExpression('LTE(a, b)', { a: 1, b: 1 })).toBe(true);
+    expect(parseExpression('LTE(a, b)', { a: 2, b: 1 })).toBe(false);
+  });
+
+  test('AND op', () => {
+    expect(parseExpression('AND(a, b)', { a: true, b: true })).toBe(true);
+    expect(parseExpression('AND(a, b)', { a: true, b: false })).toBe(false);
+    expect(parseExpression('AND(a, b)', { a: false, b: true })).toBe(false);
+    expect(parseExpression('AND(a, b)', { a: false, b: false })).toBe(false);
+  });
+
+  test('OR op', () => {
+    expect(parseExpression('OR(a, b)', { a: true, b: true })).toBe(true);
+    expect(parseExpression('OR(a, b)', { a: true, b: false })).toBe(true);
+    expect(parseExpression('OR(a, b)', { a: false, b: true })).toBe(true);
+    expect(parseExpression('OR(a, b)', { a: false, b: false })).toBe(false);
+  });
+});
+
+describe('Test parseOp', () => {
+  test('Simple unary op', () => {
+    expect(parseOp('OP_(var)')).toStrictEqual({
+      op: 'OP_',
+      a: 'var',
+      b: null,
+    });
+  });
+
+  test('Simple binary op', () => {
+    expect(parseOp('OP_(var1,var2)')).toStrictEqual({
+      op: 'OP_',
+      a: 'var1',
+      b: 'var2',
+    });
+  });
+
+  test('Literal number', () => {
+    expect(parseOp('1')).toStrictEqual(null);
+  });
+
+  test('Field value', () => {
+    expect(parseOp('a')).toStrictEqual(null);
+  });
+
+  test('Complex op 1', () => {
+    expect(parseOp('OP_(OP_(var1))')).toStrictEqual({
+      op: 'OP_',
+      a: 'OP_(var1)',
+      b: null,
+    });
+  });
+
+  test('Complex op 2', () => {
+    expect(parseOp('OP_(OP_(var1),var2)')).toStrictEqual({
+      op: 'OP_',
+      a: 'OP_(var1)',
+      b: 'var2',
+    });
+  });
+
+  test('Complex op 3', () => {
+    expect(parseOp('OP_(OP_(var1),OP_(var2))')).toStrictEqual({
+      op: 'OP_',
+      a: 'OP_(var1)',
+      b: 'OP_(var2)',
+    });
+  });
+
+  test('Complex op 4', () => {
+    expect(parseOp('OP_(OP_(OP_(var1), var2),OP_(var3))')).toStrictEqual({
+      op: 'OP_',
+      a: 'OP_(OP_(var1), var2)',
+      b: 'OP_(var3)',
+    });
+  });
+
+  test('Complex op 5', () => {
+    expect(parseOp('OP_(OP_(OP_(var1), var2),OP_(var3, OP_(var4, var5)))')).toStrictEqual({
+      op: 'OP_',
+      a: 'OP_(OP_(var1), var2)',
+      b: 'OP_(var3, OP_(var4, var5))',
+    });
+  });
+
+  test('Complex op 5', () => {
+    expect(parseOp('OP_(OP_(OP_(var1, OP_(var2, OP_(var3, var4))), var5))')).toStrictEqual({
+      op: 'OP_',
+      a: 'OP_(OP_(var1, OP_(var2, OP_(var3, var4))), var5)',
+      b: null,
+    });
+  });
 });

src/operations.ts

@@ -171,7 +171,7 @@ export function parseExpression(exp: string, values: Record<string, any>): any {
 	return '';
 }
 
-function parseOp(exp: string) {
+export function parseOp(exp: string) {
 	const match = exp.match(/^([A-Z_]+)\((.+)\)$/);
 	if (match) {
 		const op = match[1] as string;