@startsimpli/funnels 0.1.4 → 0.1.6

package/src/core/operators.test.ts

@@ -0,0 +1,539 @@
+/**
+ * @startsimpli/funnels - Operator Tests
+ *
+ * Test suite for operator implementations.
+ * Tests each operator in isolation with various data types.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { applyOperator } from './operators';
+
+// ============================================================================
+// Equality Operators
+// ============================================================================
+
+describe('Equality Operators', () => {
+  describe('eq', () => {
+    it('should match equal strings', () => {
+      expect(applyOperator('eq', 'hello', 'hello')).toBe(true);
+    });
+
+    it('should not match different strings', () => {
+      expect(applyOperator('eq', 'hello', 'world')).toBe(false);
+    });
+
+    it('should match equal numbers', () => {
+      expect(applyOperator('eq', 42, 42)).toBe(true);
+    });
+
+    it('should not match different numbers', () => {
+      expect(applyOperator('eq', 42, 43)).toBe(false);
+    });
+
+    it('should match null with null', () => {
+      expect(applyOperator('eq', null, null)).toBe(true);
+    });
+
+    it('should match undefined with undefined', () => {
+      expect(applyOperator('eq', undefined, undefined)).toBe(true);
+    });
+
+    it('should not match null with value', () => {
+      expect(applyOperator('eq', null, 'value')).toBe(false);
+    });
+  });
+
+  describe('ne', () => {
+    it('should match different strings', () => {
+      expect(applyOperator('ne', 'hello', 'world')).toBe(true);
+    });
+
+    it('should not match equal strings', () => {
+      expect(applyOperator('ne', 'hello', 'hello')).toBe(false);
+    });
+
+    it('should match different numbers', () => {
+      expect(applyOperator('ne', 42, 43)).toBe(true);
+    });
+
+    it('should not match equal numbers', () => {
+      expect(applyOperator('ne', 42, 42)).toBe(false);
+    });
+  });
+});
+
+// ============================================================================
+// Comparison Operators
+// ============================================================================
+
+describe('Comparison Operators', () => {
+  describe('gt', () => {
+    it('should match greater numbers', () => {
+      expect(applyOperator('gt', 10, 5)).toBe(true);
+    });
+
+    it('should not match equal numbers', () => {
+      expect(applyOperator('gt', 5, 5)).toBe(false);
+    });
+
+    it('should not match lesser numbers', () => {
+      expect(applyOperator('gt', 5, 10)).toBe(false);
+    });
+
+    it('should handle decimal numbers', () => {
+      expect(applyOperator('gt', 5.5, 5.4)).toBe(true);
+    });
+
+    it('should handle numeric strings', () => {
+      expect(applyOperator('gt', '10', '5')).toBe(true);
+    });
+
+    it('should compare dates', () => {
+      expect(applyOperator('gt', new Date('2024-02-01'), new Date('2024-01-01'))).toBe(true);
+    });
+  });
+
+  describe('lt', () => {
+    it('should match lesser numbers', () => {
+      expect(applyOperator('lt', 5, 10)).toBe(true);
+    });
+
+    it('should not match equal numbers', () => {
+      expect(applyOperator('lt', 5, 5)).toBe(false);
+    });
+
+    it('should not match greater numbers', () => {
+      expect(applyOperator('lt', 10, 5)).toBe(false);
+    });
+  });
+
+  describe('gte', () => {
+    it('should match greater numbers', () => {
+      expect(applyOperator('gte', 10, 5)).toBe(true);
+    });
+
+    it('should match equal numbers', () => {
+      expect(applyOperator('gte', 5, 5)).toBe(true);
+    });
+
+    it('should not match lesser numbers', () => {
+      expect(applyOperator('gte', 5, 10)).toBe(false);
+    });
+  });
+
+  describe('lte', () => {
+    it('should match lesser numbers', () => {
+      expect(applyOperator('lte', 5, 10)).toBe(true);
+    });
+
+    it('should match equal numbers', () => {
+      expect(applyOperator('lte', 5, 5)).toBe(true);
+    });
+
+    it('should not match greater numbers', () => {
+      expect(applyOperator('lte', 10, 5)).toBe(false);
+    });
+  });
+});
+
+// ============================================================================
+// String Operators
+// ============================================================================
+
+describe('String Operators', () => {
+  describe('contains', () => {
+    it('should match substring (case-insensitive)', () => {
+      expect(applyOperator('contains', 'Hello World', 'world')).toBe(true);
+    });
+
+    it('should not match non-existent substring', () => {
+      expect(applyOperator('contains', 'Hello World', 'foo')).toBe(false);
+    });
+
+    it('should handle empty substring', () => {
+      expect(applyOperator('contains', 'Hello', '')).toBe(true);
+    });
+
+    it('should return false for null actual value', () => {
+      expect(applyOperator('contains', null, 'test')).toBe(false);
+    });
+
+    it('should return false for null expected value', () => {
+      expect(applyOperator('contains', 'test', null)).toBe(false);
+    });
+  });
+
+  describe('not_contains', () => {
+    it('should match when substring absent', () => {
+      expect(applyOperator('not_contains', 'Hello World', 'foo')).toBe(true);
+    });
+
+    it('should not match when substring present', () => {
+      expect(applyOperator('not_contains', 'Hello World', 'world')).toBe(false);
+    });
+
+    it('should return true for null actual value', () => {
+      expect(applyOperator('not_contains', null, 'test')).toBe(true);
+    });
+  });
+
+  describe('startswith', () => {
+    it('should match prefix (case-insensitive)', () => {
+      expect(applyOperator('startswith', 'Hello World', 'hello')).toBe(true);
+    });
+
+    it('should not match non-prefix', () => {
+      expect(applyOperator('startswith', 'Hello World', 'world')).toBe(false);
+    });
+
+    it('should match empty string', () => {
+      expect(applyOperator('startswith', 'Hello', '')).toBe(true);
+    });
+
+    it('should return false for null', () => {
+      expect(applyOperator('startswith', null, 'test')).toBe(false);
+    });
+  });
+
+  describe('endswith', () => {
+    it('should match suffix (case-insensitive)', () => {
+      expect(applyOperator('endswith', 'Hello World', 'world')).toBe(true);
+    });
+
+    it('should not match non-suffix', () => {
+      expect(applyOperator('endswith', 'Hello World', 'hello')).toBe(false);
+    });
+
+    it('should match empty string', () => {
+      expect(applyOperator('endswith', 'Hello', '')).toBe(true);
+    });
+
+    it('should return false for null', () => {
+      expect(applyOperator('endswith', null, 'test')).toBe(false);
+    });
+  });
+
+  describe('matches', () => {
+    it('should match valid regex', () => {
+      expect(applyOperator('matches', 'test@example.com', '^[a-z]+@[a-z]+\\.[a-z]+$')).toBe(true);
+    });
+
+    it('should not match invalid regex', () => {
+      expect(applyOperator('matches', 'test', '^[0-9]+$')).toBe(false);
+    });
+
+    it('should handle regex with flags', () => {
+      expect(applyOperator('matches', 'Test123', '[a-z]+[0-9]+')).toBe(true);
+    });
+
+    it('should return false for invalid regex pattern', () => {
+      expect(applyOperator('matches', 'test', '[invalid')).toBe(false);
+    });
+
+    it('should return false for null', () => {
+      expect(applyOperator('matches', null, 'test')).toBe(false);
+    });
+  });
+});
+
+// ============================================================================
+// Array Operators
+// ============================================================================
+
+describe('Array Operators', () => {
+  describe('in', () => {
+    it('should match value in array', () => {
+      expect(applyOperator('in', 'apple', ['apple', 'banana', 'cherry'])).toBe(true);
+    });
+
+    it('should not match value not in array', () => {
+      expect(applyOperator('in', 'orange', ['apple', 'banana', 'cherry'])).toBe(false);
+    });
+
+    it('should match number in array', () => {
+      expect(applyOperator('in', 2, [1, 2, 3])).toBe(true);
+    });
+
+    it('should return false for non-array expected', () => {
+      expect(applyOperator('in', 'test', 'not-array')).toBe(false);
+    });
+
+    it('should return false for empty array', () => {
+      expect(applyOperator('in', 'test', [])).toBe(false);
+    });
+  });
+
+  describe('not_in', () => {
+    it('should match value not in array', () => {
+      expect(applyOperator('not_in', 'orange', ['apple', 'banana', 'cherry'])).toBe(true);
+    });
+
+    it('should not match value in array', () => {
+      expect(applyOperator('not_in', 'apple', ['apple', 'banana', 'cherry'])).toBe(false);
+    });
+
+    it('should return true for non-array expected', () => {
+      expect(applyOperator('not_in', 'test', 'not-array')).toBe(true);
+    });
+  });
+
+  describe('has_any', () => {
+    it('should match when array has any value', () => {
+      expect(applyOperator('has_any', ['a', 'b', 'c'], ['b', 'd'])).toBe(true);
+    });
+
+    it('should not match when array has no values', () => {
+      expect(applyOperator('has_any', ['a', 'b', 'c'], ['d', 'e'])).toBe(false);
+    });
+
+    it('should return false for non-array actual', () => {
+      expect(applyOperator('has_any', 'not-array', ['a', 'b'])).toBe(false);
+    });
+
+    it('should return false for non-array expected', () => {
+      expect(applyOperator('has_any', ['a', 'b'], 'not-array')).toBe(false);
+    });
+
+    it('should return false for empty arrays', () => {
+      expect(applyOperator('has_any', [], [])).toBe(false);
+    });
+  });
+
+  describe('has_all', () => {
+    it('should match when array has all values', () => {
+      expect(applyOperator('has_all', ['a', 'b', 'c'], ['a', 'b'])).toBe(true);
+    });
+
+    it('should not match when array missing values', () => {
+      expect(applyOperator('has_all', ['a', 'b', 'c'], ['a', 'd'])).toBe(false);
+    });
+
+    it('should match empty expected array', () => {
+      expect(applyOperator('has_all', ['a', 'b'], [])).toBe(true);
+    });
+
+    it('should return false for non-array actual', () => {
+      expect(applyOperator('has_all', 'not-array', ['a', 'b'])).toBe(false);
+    });
+
+    it('should return false for non-array expected', () => {
+      expect(applyOperator('has_all', ['a', 'b'], 'not-array')).toBe(false);
+    });
+  });
+});
+
+// ============================================================================
+// Null Operators
+// ============================================================================
+
+describe('Null Operators', () => {
+  describe('isnull', () => {
+    it('should match null', () => {
+      expect(applyOperator('isnull', null, null)).toBe(true);
+    });
+
+    it('should match undefined', () => {
+      expect(applyOperator('isnull', undefined, null)).toBe(true);
+    });
+
+    it('should not match defined values', () => {
+      expect(applyOperator('isnull', 'value', null)).toBe(false);
+    });
+
+    it('should not match empty string', () => {
+      expect(applyOperator('isnull', '', null)).toBe(false);
+    });
+
+    it('should not match zero', () => {
+      expect(applyOperator('isnull', 0, null)).toBe(false);
+    });
+
+    it('should not match false', () => {
+      expect(applyOperator('isnull', false, null)).toBe(false);
+    });
+  });
+
+  describe('isnotnull', () => {
+    it('should not match null', () => {
+      expect(applyOperator('isnotnull', null, null)).toBe(false);
+    });
+
+    it('should not match undefined', () => {
+      expect(applyOperator('isnotnull', undefined, null)).toBe(false);
+    });
+
+    it('should match defined values', () => {
+      expect(applyOperator('isnotnull', 'value', null)).toBe(true);
+    });
+
+    it('should match empty string', () => {
+      expect(applyOperator('isnotnull', '', null)).toBe(true);
+    });
+
+    it('should match zero', () => {
+      expect(applyOperator('isnotnull', 0, null)).toBe(true);
+    });
+
+    it('should match false', () => {
+      expect(applyOperator('isnotnull', false, null)).toBe(true);
+    });
+  });
+});
+
+// ============================================================================
+// Tag Operators
+// ============================================================================
+
+describe('Tag Operators', () => {
+  describe('has_tag', () => {
+    it('should match tag in array (case-insensitive)', () => {
+      expect(applyOperator('has_tag', ['active', 'qualified'], 'QUALIFIED')).toBe(true);
+    });
+
+    it('should not match missing tag', () => {
+      expect(applyOperator('has_tag', ['active', 'qualified'], 'premium')).toBe(false);
+    });
+
+    it('should return false for non-array', () => {
+      expect(applyOperator('has_tag', 'not-array', 'tag')).toBe(false);
+    });
+
+    it('should return false for empty array', () => {
+      expect(applyOperator('has_tag', [], 'tag')).toBe(false);
+    });
+
+    it('should return false for null expected', () => {
+      expect(applyOperator('has_tag', ['active'], null)).toBe(false);
+    });
+  });
+
+  describe('not_has_tag', () => {
+    it('should match when tag absent', () => {
+      expect(applyOperator('not_has_tag', ['active', 'qualified'], 'premium')).toBe(true);
+    });
+
+    it('should not match when tag present', () => {
+      expect(applyOperator('not_has_tag', ['active', 'qualified'], 'ACTIVE')).toBe(false);
+    });
+
+    it('should return true for non-array', () => {
+      expect(applyOperator('not_has_tag', 'not-array', 'tag')).toBe(true);
+    });
+
+    it('should return true for empty array', () => {
+      expect(applyOperator('not_has_tag', [], 'tag')).toBe(true);
+    });
+  });
+});
+
+// ============================================================================
+// Boolean Operators
+// ============================================================================
+
+describe('Boolean Operators', () => {
+  describe('is_true', () => {
+    it('should match true', () => {
+      expect(applyOperator('is_true', true, null)).toBe(true);
+    });
+
+    it('should not match false', () => {
+      expect(applyOperator('is_true', false, null)).toBe(false);
+    });
+
+    it('should not match truthy values', () => {
+      expect(applyOperator('is_true', 1, null)).toBe(false);
+      expect(applyOperator('is_true', 'true', null)).toBe(false);
+    });
+
+    it('should not match null', () => {
+      expect(applyOperator('is_true', null, null)).toBe(false);
+    });
+  });
+
+  describe('is_false', () => {
+    it('should match false', () => {
+      expect(applyOperator('is_false', false, null)).toBe(true);
+    });
+
+    it('should not match true', () => {
+      expect(applyOperator('is_false', true, null)).toBe(false);
+    });
+
+    it('should not match falsy values', () => {
+      expect(applyOperator('is_false', 0, null)).toBe(false);
+      expect(applyOperator('is_false', '', null)).toBe(false);
+    });
+
+    it('should not match null', () => {
+      expect(applyOperator('is_false', null, null)).toBe(false);
+    });
+  });
+});
+
+// ============================================================================
+// Date Handling
+// ============================================================================
+
+describe('Date Handling', () => {
+  it('should compare Date objects', () => {
+    const date1 = new Date('2024-01-15');
+    const date2 = new Date('2024-01-01');
+    expect(applyOperator('gt', date1, date2)).toBe(true);
+  });
+
+  it('should compare date strings', () => {
+    expect(applyOperator('gt', '2024-01-15', '2024-01-01')).toBe(true);
+  });
+
+  it('should compare Date with string', () => {
+    const date = new Date('2024-01-15');
+    expect(applyOperator('eq', date, '2024-01-15')).toBe(true);
+  });
+
+  it('should handle invalid dates', () => {
+    expect(applyOperator('gt', 'invalid-date', '2024-01-01')).toBe(false);
+  });
+});
+
+// ============================================================================
+// Type Coercion
+// ============================================================================
+
+describe('Type Coercion', () => {
+  it('should handle numeric string comparisons', () => {
+    expect(applyOperator('gt', '10', '5')).toBe(true);
+    expect(applyOperator('lt', '5', '10')).toBe(true);
+  });
+
+  it('should handle mixed number and string', () => {
+    expect(applyOperator('eq', 42, '42')).toBe(true);
+    expect(applyOperator('gt', 10, '5')).toBe(true);
+  });
+
+  it('should handle decimal strings', () => {
+    expect(applyOperator('gt', '10.5', '10.2')).toBe(true);
+  });
+
+  it('should not coerce non-numeric strings', () => {
+    expect(applyOperator('eq', 'hello', 123)).toBe(false);
+  });
+});
+
+// ============================================================================
+// Error Handling
+// ============================================================================
+
+describe('Error Handling', () => {
+  it('should throw for unknown operator', () => {
+    expect(() => applyOperator('unknown' as any, 'test', 'test')).toThrow('Unknown operator');
+  });
+
+  it('should handle invalid regex gracefully', () => {
+    expect(applyOperator('matches', 'test', '[invalid')).toBe(false);
+  });
+
+  it('should handle null/undefined gracefully', () => {
+    expect(applyOperator('contains', null, 'test')).toBe(false);
+    expect(applyOperator('startswith', undefined, 'test')).toBe(false);
+  });
+});