@startsimpli/funnels 0.1.4 → 0.1.5

package/src/core/evaluator.test.ts

@@ -0,0 +1,639 @@
+/**
+ * @startsimpli/funnels - Rule Evaluator Tests
+ *
+ * Comprehensive test suite for rule evaluation engine.
+ * Tests ALL operators with different data types.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  evaluateRule,
+  evaluateRuleWithResult,
+  evaluateRules,
+  evaluateRulesAND,
+  evaluateRulesOR,
+  evaluateRulesWithResults,
+  filterEntities,
+} from './evaluator';
+import type { FilterRule } from '../types';
+
+// ============================================================================
+// Test Data
+// ============================================================================
+
+interface TestEntity {
+  id?: number;
+  name?: string;
+  email?: string | null;
+  age?: number;
+  score?: number;
+  active?: boolean;
+  tags?: string[];
+  created_at?: Date | string;
+  firm?: {
+    name?: string;
+    stage?: string;
+    aum?: number;
+  };
+  profile?: {
+    linkedin_url?: string | null;
+    twitter_handle?: string;
+  };
+  metrics?: {
+    arr_usd?: number;
+    employees?: number;
+  };
+}
+
+const sampleEntity: TestEntity = {
+  id: 1,
+  name: 'John Doe',
+  email: 'john@example.com',
+  age: 35,
+  score: 85.5,
+  active: true,
+  tags: ['qualified', 'active', 'premium'],
+  created_at: new Date('2024-01-15'),
+  firm: {
+    name: 'Acme Ventures',
+    stage: 'Series A',
+    aum: 100000000,
+  },
+  profile: {
+    linkedin_url: 'https://linkedin.com/in/johndoe',
+    twitter_handle: '@johndoe',
+  },
+  metrics: {
+    arr_usd: 5000000,
+    employees: 50,
+  },
+};
+
+// ============================================================================
+// Equality Operators
+// ============================================================================
+
+describe('Equality Operators', () => {
+  it('eq: should match equal values', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'eq', value: 'John Doe' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('eq: should not match different values', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'eq', value: 'Jane Doe' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('eq: should match numbers', () => {
+    const rule: FilterRule = { field_path: 'age', operator: 'eq', value: 35 };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('eq: should match nested fields', () => {
+    const rule: FilterRule = { field_path: 'firm.stage', operator: 'eq', value: 'Series A' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('ne: should match different values', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'ne', value: 'Jane Doe' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('ne: should not match equal values', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'ne', value: 'John Doe' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+});
+
+// ============================================================================
+// Comparison Operators
+// ============================================================================
+
+describe('Comparison Operators', () => {
+  it('gt: should match greater values', () => {
+    const rule: FilterRule = { field_path: 'age', operator: 'gt', value: 30 };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('gt: should not match equal or lesser values', () => {
+    const rule: FilterRule = { field_path: 'age', operator: 'gt', value: 35 };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('lt: should match lesser values', () => {
+    const rule: FilterRule = { field_path: 'age', operator: 'lt', value: 40 };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('lt: should not match equal or greater values', () => {
+    const rule: FilterRule = { field_path: 'age', operator: 'lt', value: 35 };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('gte: should match greater or equal values', () => {
+    const rule1: FilterRule = { field_path: 'age', operator: 'gte', value: 35 };
+    const rule2: FilterRule = { field_path: 'age', operator: 'gte', value: 30 };
+    expect(evaluateRule(sampleEntity, rule1)).toBe(true);
+    expect(evaluateRule(sampleEntity, rule2)).toBe(true);
+  });
+
+  it('gte: should not match lesser values', () => {
+    const rule: FilterRule = { field_path: 'age', operator: 'gte', value: 40 };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('lte: should match lesser or equal values', () => {
+    const rule1: FilterRule = { field_path: 'age', operator: 'lte', value: 35 };
+    const rule2: FilterRule = { field_path: 'age', operator: 'lte', value: 40 };
+    expect(evaluateRule(sampleEntity, rule1)).toBe(true);
+    expect(evaluateRule(sampleEntity, rule2)).toBe(true);
+  });
+
+  it('lte: should not match greater values', () => {
+    const rule: FilterRule = { field_path: 'age', operator: 'lte', value: 30 };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('should compare decimal numbers', () => {
+    const rule: FilterRule = { field_path: 'score', operator: 'gt', value: 85 };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('should compare nested numbers', () => {
+    const rule: FilterRule = { field_path: 'firm.aum', operator: 'gte', value: 100000000 };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+});
+
+// ============================================================================
+// String Operators
+// ============================================================================
+
+describe('String Operators', () => {
+  it('contains: should match substring (case-insensitive)', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'contains', value: 'john' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('contains: should not match non-existent substring', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'contains', value: 'jane' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('contains: should match nested string', () => {
+    const rule: FilterRule = { field_path: 'firm.name', operator: 'contains', value: 'acme' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('not_contains: should match when substring absent', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'not_contains', value: 'jane' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('not_contains: should not match when substring present', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'not_contains', value: 'john' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('startswith: should match prefix (case-insensitive)', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'startswith', value: 'john' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('startswith: should not match non-prefix', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'startswith', value: 'doe' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('endswith: should match suffix (case-insensitive)', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'endswith', value: 'doe' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('endswith: should not match non-suffix', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'endswith', value: 'john' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('matches: should match regex pattern', () => {
+    const rule: FilterRule = { field_path: 'email', operator: 'matches', value: '^[a-z]+@example\\.com$' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('matches: should not match non-matching pattern', () => {
+    const rule: FilterRule = { field_path: 'email', operator: 'matches', value: '^[0-9]+@' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+});
+
+// ============================================================================
+// Array Operators
+// ============================================================================
+
+describe('Array Operators', () => {
+  it('in: should match value in array', () => {
+    const rule: FilterRule = { field_path: 'firm.stage', operator: 'in', value: ['Seed', 'Series A', 'Series B'] };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('in: should not match value not in array', () => {
+    const rule: FilterRule = { field_path: 'firm.stage', operator: 'in', value: ['Seed', 'Series B'] };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('not_in: should match value not in array', () => {
+    const rule: FilterRule = { field_path: 'firm.stage', operator: 'not_in', value: ['Seed', 'Series B'] };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('not_in: should not match value in array', () => {
+    const rule: FilterRule = { field_path: 'firm.stage', operator: 'not_in', value: ['Series A', 'Series B'] };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('has_any: should match when array has any value', () => {
+    const rule: FilterRule = { field_path: 'tags', operator: 'has_any', value: ['qualified', 'inactive'] };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('has_any: should not match when array has no values', () => {
+    const rule: FilterRule = { field_path: 'tags', operator: 'has_any', value: ['inactive', 'suspended'] };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('has_all: should match when array has all values', () => {
+    const rule: FilterRule = { field_path: 'tags', operator: 'has_all', value: ['qualified', 'active'] };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('has_all: should not match when array missing some values', () => {
+    const rule: FilterRule = { field_path: 'tags', operator: 'has_all', value: ['qualified', 'inactive'] };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+});
+
+// ============================================================================
+// Null Operators
+// ============================================================================
+
+describe('Null Operators', () => {
+  const entityWithNulls: TestEntity = {
+    name: 'John',
+    email: null,
+    profile: {
+      linkedin_url: null,
+    },
+  };
+
+  it('isnull: should match null values', () => {
+    const rule: FilterRule = { field_path: 'email', operator: 'isnull', value: null };
+    expect(evaluateRule(entityWithNulls, rule)).toBe(true);
+  });
+
+  it('isnull: should match undefined values', () => {
+    const rule: FilterRule = { field_path: 'age', operator: 'isnull', value: null };
+    expect(evaluateRule(entityWithNulls, rule)).toBe(true);
+  });
+
+  it('isnull: should not match defined values', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'isnull', value: null };
+    expect(evaluateRule(entityWithNulls, rule)).toBe(false);
+  });
+
+  it('isnull: should match nested null', () => {
+    const rule: FilterRule = { field_path: 'profile.linkedin_url', operator: 'isnull', value: null };
+    expect(evaluateRule(entityWithNulls, rule)).toBe(true);
+  });
+
+  it('isnotnull: should match defined values', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'isnotnull', value: null };
+    expect(evaluateRule(entityWithNulls, rule)).toBe(true);
+  });
+
+  it('isnotnull: should not match null values', () => {
+    const rule: FilterRule = { field_path: 'email', operator: 'isnotnull', value: null };
+    expect(evaluateRule(entityWithNulls, rule)).toBe(false);
+  });
+
+  it('isnotnull: should not match undefined values', () => {
+    const rule: FilterRule = { field_path: 'age', operator: 'isnotnull', value: null };
+    expect(evaluateRule(entityWithNulls, rule)).toBe(false);
+  });
+});
+
+// ============================================================================
+// Tag Operators
+// ============================================================================
+
+describe('Tag Operators', () => {
+  it('has_tag: should match tag in array (case-insensitive)', () => {
+    const rule: FilterRule = { field_path: 'tags', operator: 'has_tag', value: 'QUALIFIED' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('has_tag: should not match missing tag', () => {
+    const rule: FilterRule = { field_path: 'tags', operator: 'has_tag', value: 'inactive' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('not_has_tag: should match when tag absent', () => {
+    const rule: FilterRule = { field_path: 'tags', operator: 'not_has_tag', value: 'inactive' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('not_has_tag: should not match when tag present', () => {
+    const rule: FilterRule = { field_path: 'tags', operator: 'not_has_tag', value: 'qualified' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+});
+
+// ============================================================================
+// Boolean Operators
+// ============================================================================
+
+describe('Boolean Operators', () => {
+  it('is_true: should match true values', () => {
+    const rule: FilterRule = { field_path: 'active', operator: 'is_true', value: null };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('is_true: should not match false values', () => {
+    const entity = { ...sampleEntity, active: false };
+    const rule: FilterRule = { field_path: 'active', operator: 'is_true', value: null };
+    expect(evaluateRule(entity, rule)).toBe(false);
+  });
+
+  it('is_false: should match false values', () => {
+    const entity = { ...sampleEntity, active: false };
+    const rule: FilterRule = { field_path: 'active', operator: 'is_false', value: null };
+    expect(evaluateRule(entity, rule)).toBe(true);
+  });
+
+  it('is_false: should not match true values', () => {
+    const rule: FilterRule = { field_path: 'active', operator: 'is_false', value: null };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+});
+
+// ============================================================================
+// Date Operators
+// ============================================================================
+
+describe('Date Operators', () => {
+  it('should compare Date objects', () => {
+    const rule: FilterRule = {
+      field_path: 'created_at',
+      operator: 'gt',
+      value: new Date('2024-01-01'),
+    };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('should compare date strings', () => {
+    const entity = { ...sampleEntity, created_at: '2024-01-15' };
+    const rule: FilterRule = {
+      field_path: 'created_at',
+      operator: 'gte',
+      value: '2024-01-15',
+    };
+    expect(evaluateRule(entity, rule)).toBe(true);
+  });
+
+  it('should handle date equality', () => {
+    const entity = { ...sampleEntity, created_at: '2024-01-15' };
+    const rule: FilterRule = {
+      field_path: 'created_at',
+      operator: 'eq',
+      value: new Date('2024-01-15'),
+    };
+    expect(evaluateRule(entity, rule)).toBe(true);
+  });
+});
+
+// ============================================================================
+// Negate Flag
+// ============================================================================
+
+describe('Negate Flag', () => {
+  it('should negate equality', () => {
+    const rule: FilterRule = {
+      field_path: 'name',
+      operator: 'eq',
+      value: 'John Doe',
+      negate: true,
+    };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('should negate inequality', () => {
+    const rule: FilterRule = {
+      field_path: 'name',
+      operator: 'ne',
+      value: 'John Doe',
+      negate: true,
+    };
+    expect(evaluateRule(sampleEntity, rule)).toBe(true);
+  });
+
+  it('should negate contains', () => {
+    const rule: FilterRule = {
+      field_path: 'name',
+      operator: 'contains',
+      value: 'john',
+      negate: true,
+    };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+});
+
+// ============================================================================
+// Edge Cases
+// ============================================================================
+
+describe('Edge Cases', () => {
+  it('should handle missing nested paths', () => {
+    const rule: FilterRule = { field_path: 'firm.missing.field', operator: 'eq', value: 'test' };
+    expect(evaluateRule(sampleEntity, rule)).toBe(false);
+  });
+
+  it('should handle empty strings', () => {
+    const entity = { name: '' };
+    const rule: FilterRule = { field_path: 'name', operator: 'eq', value: '' };
+    expect(evaluateRule(entity, rule)).toBe(true);
+  });
+
+  it('should handle empty arrays', () => {
+    const entity = { tags: [] };
+    const rule: FilterRule = { field_path: 'tags', operator: 'has_tag', value: 'test' };
+    expect(evaluateRule(entity, rule)).toBe(false);
+  });
+
+  it('should handle zero values', () => {
+    const entity = { score: 0 };
+    const rule: FilterRule = { field_path: 'score', operator: 'eq', value: 0 };
+    expect(evaluateRule(entity, rule)).toBe(true);
+  });
+
+  it('should handle numeric strings in comparisons', () => {
+    const entity = { age: '35' };
+    const rule: FilterRule = { field_path: 'age', operator: 'gt', value: 30 };
+    expect(evaluateRule(entity, rule)).toBe(true);
+  });
+});
+
+// ============================================================================
+// Multiple Rules (AND/OR)
+// ============================================================================
+
+describe('Multiple Rules', () => {
+  const rules: FilterRule[] = [
+    { field_path: 'age', operator: 'gte', value: 30 },
+    { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
+    { field_path: 'tags', operator: 'has_tag', value: 'qualified' },
+  ];
+
+  it('AND: should match when all rules pass', () => {
+    expect(evaluateRulesAND(sampleEntity, rules)).toBe(true);
+  });
+
+  it('AND: should not match when any rule fails', () => {
+    const failingRules = [
+      ...rules,
+      { field_path: 'age', operator: 'lt', value: 30 } as FilterRule,
+    ];
+    expect(evaluateRulesAND(sampleEntity, failingRules)).toBe(false);
+  });
+
+  it('OR: should match when any rule passes', () => {
+    const orRules: FilterRule[] = [
+      { field_path: 'age', operator: 'lt', value: 30 }, // false
+      { field_path: 'firm.stage', operator: 'eq', value: 'Series A' }, // true
+    ];
+    expect(evaluateRulesOR(sampleEntity, orRules)).toBe(true);
+  });
+
+  it('OR: should not match when all rules fail', () => {
+    const orRules: FilterRule[] = [
+      { field_path: 'age', operator: 'lt', value: 30 },
+      { field_path: 'firm.stage', operator: 'eq', value: 'Seed' },
+    ];
+    expect(evaluateRulesOR(sampleEntity, orRules)).toBe(false);
+  });
+
+  it('evaluateRules: should use AND logic by default', () => {
+    expect(evaluateRules(sampleEntity, rules)).toBe(true);
+  });
+
+  it('evaluateRules: should use specified logic', () => {
+    const orRules: FilterRule[] = [
+      { field_path: 'age', operator: 'lt', value: 30 },
+      { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
+    ];
+    expect(evaluateRules(sampleEntity, orRules, 'OR')).toBe(true);
+  });
+
+  it('should handle empty rules (match all)', () => {
+    expect(evaluateRulesAND(sampleEntity, [])).toBe(true);
+    expect(evaluateRulesOR(sampleEntity, [])).toBe(true);
+  });
+});
+
+// ============================================================================
+// Detailed Results
+// ============================================================================
+
+describe('Detailed Results', () => {
+  it('should return detailed rule result', () => {
+    const rule: FilterRule = { field_path: 'firm.stage', operator: 'eq', value: 'Series A' };
+    const result = evaluateRuleWithResult(sampleEntity, rule);
+
+    expect(result).toEqual({
+      field_path: 'firm.stage',
+      operator: 'eq',
+      value: 'Series A',
+      actual_value: 'Series A',
+      matched: true,
+    });
+  });
+
+  it('should return detailed results for multiple rules', () => {
+    const rules: FilterRule[] = [
+      { field_path: 'age', operator: 'gte', value: 30 },
+      { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
+    ];
+
+    const result = evaluateRulesWithResults(sampleEntity, rules, 'AND');
+
+    expect(result.matched).toBe(true);
+    expect(result.logic).toBe('AND');
+    expect(result.rule_results).toHaveLength(2);
+    expect(result.rule_results[0].matched).toBe(true);
+    expect(result.rule_results[1].matched).toBe(true);
+  });
+
+  it('should handle errors in rule evaluation', () => {
+    const rule: FilterRule = { field_path: 'name', operator: 'matches' as any, value: '[invalid-regex' };
+    const result = evaluateRuleWithResult(sampleEntity, rule);
+
+    expect(result.matched).toBe(false);
+    expect(result.error).toBeUndefined(); // Invalid regex returns false, doesn't throw
+  });
+});
+
+// ============================================================================
+// Filter Entities
+// ============================================================================
+
+describe('Filter Entities', () => {
+  const entities: TestEntity[] = [
+    { id: 1, name: 'John', age: 35, firm: { stage: 'Series A' } },
+    { id: 2, name: 'Jane', age: 28, firm: { stage: 'Seed' } },
+    { id: 3, name: 'Bob', age: 42, firm: { stage: 'Series B' } },
+  ];
+
+  it('should filter entities with single rule', () => {
+    const rules: FilterRule[] = [
+      { field_path: 'firm.stage', operator: 'eq', value: 'Series A' },
+    ];
+
+    const result = filterEntities(entities, rules);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe('John');
+  });
+
+  it('should filter entities with multiple AND rules', () => {
+    const rules: FilterRule[] = [
+      { field_path: 'age', operator: 'gte', value: 30 },
+      { field_path: 'firm.stage', operator: 'in', value: ['Series A', 'Series B'] },
+    ];
+
+    const result = filterEntities(entities, rules, 'AND');
+    expect(result).toHaveLength(2);
+    expect(result.map(e => e.name)).toEqual(['John', 'Bob']);
+  });
+
+  it('should filter entities with OR rules', () => {
+    const rules: FilterRule[] = [
+      { field_path: 'age', operator: 'lt', value: 30 },
+      { field_path: 'firm.stage', operator: 'eq', value: 'Series B' },
+    ];
+
+    const result = filterEntities(entities, rules, 'OR');
+    expect(result).toHaveLength(2);
+    expect(result.map(e => e.name)).toEqual(['Jane', 'Bob']);
+  });
+
+  it('should return all entities with no rules', () => {
+    const result = filterEntities(entities, []);
+    expect(result).toHaveLength(3);
+  });
+
+  it('should return empty array for no matches', () => {
+    const rules: FilterRule[] = [
+      { field_path: 'age', operator: 'gt', value: 100 },
+    ];
+
+    const result = filterEntities(entities, rules);
+    expect(result).toHaveLength(0);
+  });
+});