@startsimpli/funnels 0.1.3 → 0.1.5

package/src/components/FilterRuleEditor/FilterRuleEditor.test.tsx

@@ -0,0 +1,520 @@
+/**
+ * FilterRuleEditor Component Tests
+ *
+ * Tests the BRUTALLY GENERIC filter rule builder with different entity types.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { FilterRule, FieldDefinition, FilterLogic } from '../../types';
+import { validateFilterRule } from '../../types';
+
+// ============================================================================
+// Mock Field Registries - Shows genericness!
+// ============================================================================
+
+/**
+ * Investor field registry
+ */
+const investorFieldRegistry: FieldDefinition[] = [
+  {
+    name: 'name',
+    label: 'Name',
+    type: 'string',
+    category: 'Profile',
+    operators: ['eq', 'ne', 'contains', 'startswith'],
+  },
+  {
+    name: 'email',
+    label: 'Email',
+    type: 'string',
+    category: 'Profile',
+    operators: ['eq', 'contains', 'isnotnull'],
+  },
+  {
+    name: 'firm.stage',
+    label: 'Firm Stage',
+    type: 'string',
+    category: 'Investment',
+    operators: ['eq', 'ne', 'in'],
+    constraints: {
+      choices: ['Seed', 'Series A', 'Series B', 'Series C', 'Growth'],
+    },
+  },
+  {
+    name: 'firm.check_size_min',
+    label: 'Check Size Min',
+    type: 'number',
+    category: 'Investment',
+    operators: ['eq', 'ne', 'gt', 'lt', 'gte', 'lte'],
+    constraints: {
+      min_value: 0,
+    },
+  },
+  {
+    name: 'metrics.icp_score',
+    label: 'ICP Score',
+    type: 'number',
+    category: 'Metrics',
+    operators: ['eq', 'ne', 'gt', 'lt', 'gte', 'lte'],
+    constraints: {
+      min_value: 0,
+      max_value: 100,
+    },
+  },
+  {
+    name: 'tags',
+    label: 'Tags',
+    type: 'tag',
+    category: 'Metadata',
+    operators: ['has_tag', 'not_has_tag'],
+  },
+];
+
+/**
+ * Recipe field registry - completely different domain!
+ */
+const recipeFieldRegistry: FieldDefinition[] = [
+  {
+    name: 'title',
+    label: 'Recipe Title',
+    type: 'string',
+    category: 'Basic Info',
+    operators: ['eq', 'contains', 'startswith'],
+  },
+  {
+    name: 'cuisine',
+    label: 'Cuisine',
+    type: 'string',
+    category: 'Classification',
+    operators: ['eq', 'in'],
+    constraints: {
+      choices: ['Italian', 'French', 'Chinese', 'Japanese', 'Mexican', 'Indian'],
+    },
+  },
+  {
+    name: 'difficulty',
+    label: 'Difficulty Level',
+    type: 'string',
+    category: 'Classification',
+    operators: ['eq', 'in'],
+    constraints: {
+      choices: ['Easy', 'Medium', 'Hard'],
+    },
+  },
+  {
+    name: 'prep_time_minutes',
+    label: 'Prep Time (min)',
+    type: 'number',
+    category: 'Time',
+    operators: ['eq', 'ne', 'gt', 'lt', 'gte', 'lte'],
+    constraints: {
+      min_value: 0,
+    },
+  },
+  {
+    name: 'is_vegetarian',
+    label: 'Vegetarian',
+    type: 'boolean',
+    category: 'Dietary',
+    operators: ['eq', 'is_true', 'is_false'],
+  },
+  {
+    name: 'created_at',
+    label: 'Created Date',
+    type: 'date',
+    category: 'Metadata',
+    operators: ['eq', 'ne', 'gt', 'lt', 'gte', 'lte'],
+  },
+];
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe('FilterRuleEditor - Generic Validation', () => {
+  it('validates empty field_path', () => {
+    const rule: FilterRule = {
+      field_path: '',
+      operator: 'eq',
+      value: 'test',
+    };
+
+    const errors = validateFilterRule(rule);
+    expect(errors).toContain('field_path is required');
+  });
+
+  it('validates missing operator', () => {
+    const rule: FilterRule = {
+      field_path: 'name',
+      operator: '' as any,
+      value: 'test',
+    };
+
+    const errors = validateFilterRule(rule);
+    expect(errors).toContain('operator is required');
+  });
+
+  it('validates missing value for operators that need it', () => {
+    const rule: FilterRule = {
+      field_path: 'name',
+      operator: 'eq',
+      value: undefined,
+    };
+
+    const errors = validateFilterRule(rule);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors[0]).toContain('value is required');
+  });
+
+  it('allows null value for null-check operators', () => {
+    const nullOps = ['isnull', 'isnotnull', 'is_true', 'is_false'];
+
+    nullOps.forEach((op) => {
+      const rule: FilterRule = {
+        field_path: 'email',
+        operator: op as any,
+        value: null,
+      };
+
+      const errors = validateFilterRule(rule);
+      expect(errors).toEqual([]);
+    });
+  });
+});
+
+describe('FilterRuleEditor - Investor Domain', () => {
+  it('creates string equality rule', () => {
+    const rule: FilterRule = {
+      field_path: 'name',
+      operator: 'eq',
+      value: 'John Doe',
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+
+  it('creates string contains rule', () => {
+    const rule: FilterRule = {
+      field_path: 'email',
+      operator: 'contains',
+      value: '@vc.com',
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+
+  it('creates choice equality rule', () => {
+    const rule: FilterRule = {
+      field_path: 'firm.stage',
+      operator: 'eq',
+      value: 'Series A',
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+
+  it('creates choice multi-select rule', () => {
+    const rule: FilterRule = {
+      field_path: 'firm.stage',
+      operator: 'in',
+      value: ['Series A', 'Series B', 'Series C'],
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+
+  it('creates number comparison rule', () => {
+    const rule: FilterRule = {
+      field_path: 'firm.check_size_min',
+      operator: 'gte',
+      value: 1000000,
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+
+  it('creates number range rule', () => {
+    const rule: FilterRule = {
+      field_path: 'metrics.icp_score',
+      operator: 'gte',
+      value: 80,
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+
+  it('creates tag rule', () => {
+    const rule: FilterRule = {
+      field_path: 'tags',
+      operator: 'has_tag',
+      value: 'priority',
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+});
+
+describe('FilterRuleEditor - Recipe Domain', () => {
+  it('creates recipe title search rule', () => {
+    const rule: FilterRule = {
+      field_path: 'title',
+      operator: 'contains',
+      value: 'pasta',
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+
+  it('creates cuisine filter rule', () => {
+    const rule: FilterRule = {
+      field_path: 'cuisine',
+      operator: 'eq',
+      value: 'Italian',
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+
+  it('creates multiple cuisine rule', () => {
+    const rule: FilterRule = {
+      field_path: 'cuisine',
+      operator: 'in',
+      value: ['Italian', 'French', 'Japanese'],
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+
+  it('creates difficulty filter rule', () => {
+    const rule: FilterRule = {
+      field_path: 'difficulty',
+      operator: 'eq',
+      value: 'Easy',
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+
+  it('creates prep time rule', () => {
+    const rule: FilterRule = {
+      field_path: 'prep_time_minutes',
+      operator: 'lte',
+      value: 30,
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+
+  it('creates boolean rule', () => {
+    const rule: FilterRule = {
+      field_path: 'is_vegetarian',
+      operator: 'is_true',
+      value: null,
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+
+  it('creates date comparison rule', () => {
+    const rule: FilterRule = {
+      field_path: 'created_at',
+      operator: 'gte',
+      value: '2024-01-01',
+    };
+
+    expect(validateFilterRule(rule)).toEqual([]);
+  });
+});
+
+describe('FilterRuleEditor - Complex Multi-Rule Scenarios', () => {
+  it('validates AND logic with multiple rules', () => {
+    const rules: FilterRule[] = [
+      {
+        field_path: 'firm.stage',
+        operator: 'in',
+        value: ['Series A', 'Series B'],
+      },
+      {
+        field_path: 'firm.check_size_min',
+        operator: 'gte',
+        value: 500000,
+      },
+      {
+        field_path: 'metrics.icp_score',
+        operator: 'gte',
+        value: 70,
+      },
+    ];
+
+    rules.forEach((rule) => {
+      expect(validateFilterRule(rule)).toEqual([]);
+    });
+  });
+
+  it('validates OR logic with different field types', () => {
+    const rules: FilterRule[] = [
+      {
+        field_path: 'name',
+        operator: 'contains',
+        value: 'Acme',
+      },
+      {
+        field_path: 'tags',
+        operator: 'has_tag',
+        value: 'hot-lead',
+      },
+      {
+        field_path: 'metrics.icp_score',
+        operator: 'gte',
+        value: 90,
+      },
+    ];
+
+    rules.forEach((rule) => {
+      expect(validateFilterRule(rule)).toEqual([]);
+    });
+  });
+
+  it('validates recipe filter with multiple conditions', () => {
+    const rules: FilterRule[] = [
+      {
+        field_path: 'cuisine',
+        operator: 'in',
+        value: ['Italian', 'French'],
+      },
+      {
+        field_path: 'difficulty',
+        operator: 'eq',
+        value: 'Easy',
+      },
+      {
+        field_path: 'prep_time_minutes',
+        operator: 'lte',
+        value: 30,
+      },
+      {
+        field_path: 'is_vegetarian',
+        operator: 'is_true',
+        value: null,
+      },
+    ];
+
+    rules.forEach((rule) => {
+      expect(validateFilterRule(rule)).toEqual([]);
+    });
+  });
+});
+
+describe('FilterRuleEditor - Field Registry Grouping', () => {
+  it('groups investor fields by category', () => {
+    const grouped = investorFieldRegistry.reduce((acc, field) => {
+      const category = field.category || 'Other';
+      if (!acc[category]) {
+        acc[category] = [];
+      }
+      acc[category].push(field);
+      return acc;
+    }, {} as Record<string, FieldDefinition[]>);
+
+    expect(Object.keys(grouped)).toContain('Profile');
+    expect(Object.keys(grouped)).toContain('Investment');
+    expect(Object.keys(grouped)).toContain('Metrics');
+    expect(grouped['Profile'].length).toBe(2);
+    expect(grouped['Investment'].length).toBe(2);
+  });
+
+  it('groups recipe fields by category', () => {
+    const grouped = recipeFieldRegistry.reduce((acc, field) => {
+      const category = field.category || 'Other';
+      if (!acc[category]) {
+        acc[category] = [];
+      }
+      acc[category].push(field);
+      return acc;
+    }, {} as Record<string, FieldDefinition[]>);
+
+    expect(Object.keys(grouped)).toContain('Basic Info');
+    expect(Object.keys(grouped)).toContain('Classification');
+    expect(Object.keys(grouped)).toContain('Time');
+    expect(Object.keys(grouped)).toContain('Dietary');
+  });
+});
+
+describe('FilterRuleEditor - Operator Filtering', () => {
+  it('provides correct operators for string fields', () => {
+    const nameField = investorFieldRegistry.find((f) => f.name === 'name');
+    expect(nameField?.operators).toContain('eq');
+    expect(nameField?.operators).toContain('contains');
+    expect(nameField?.operators).toContain('startswith');
+  });
+
+  it('provides correct operators for number fields', () => {
+    const checkSizeField = investorFieldRegistry.find(
+      (f) => f.name === 'firm.check_size_min'
+    );
+    expect(checkSizeField?.operators).toContain('gt');
+    expect(checkSizeField?.operators).toContain('gte');
+    expect(checkSizeField?.operators).toContain('lte');
+  });
+
+  it('provides correct operators for choice fields', () => {
+    const stageField = investorFieldRegistry.find((f) => f.name === 'firm.stage');
+    expect(stageField?.operators).toContain('eq');
+    expect(stageField?.operators).toContain('in');
+  });
+
+  it('provides correct operators for tag fields', () => {
+    const tagsField = investorFieldRegistry.find((f) => f.name === 'tags');
+    expect(tagsField?.operators).toContain('has_tag');
+    expect(tagsField?.operators).toContain('not_has_tag');
+  });
+
+  it('provides correct operators for boolean fields', () => {
+    const vegField = recipeFieldRegistry.find((f) => f.name === 'is_vegetarian');
+    expect(vegField?.operators).toContain('eq');
+    expect(vegField?.operators).toContain('is_true');
+    expect(vegField?.operators).toContain('is_false');
+  });
+
+  it('provides correct operators for date fields', () => {
+    const dateField = recipeFieldRegistry.find((f) => f.name === 'created_at');
+    expect(dateField?.operators).toContain('eq');
+    expect(dateField?.operators).toContain('gt');
+    expect(dateField?.operators).toContain('lte');
+  });
+});
+
+describe('FilterRuleEditor - Value Constraints', () => {
+  it('validates choice constraints for firm stage', () => {
+    const stageField = investorFieldRegistry.find((f) => f.name === 'firm.stage');
+    expect(stageField?.constraints?.choices).toEqual([
+      'Seed',
+      'Series A',
+      'Series B',
+      'Series C',
+      'Growth',
+    ]);
+  });
+
+  it('validates choice constraints for cuisine', () => {
+    const cuisineField = recipeFieldRegistry.find((f) => f.name === 'cuisine');
+    expect(cuisineField?.constraints?.choices).toContain('Italian');
+    expect(cuisineField?.constraints?.choices).toContain('French');
+    expect(cuisineField?.constraints?.choices).toContain('Japanese');
+  });
+
+  it('validates number constraints for ICP score', () => {
+    const scoreField = investorFieldRegistry.find(
+      (f) => f.name === 'metrics.icp_score'
+    );
+    expect(scoreField?.constraints?.min_value).toBe(0);
+    expect(scoreField?.constraints?.max_value).toBe(100);
+  });
+
+  it('validates number constraints for prep time', () => {
+    const prepField = recipeFieldRegistry.find(
+      (f) => f.name === 'prep_time_minutes'
+    );
+    expect(prepField?.constraints?.min_value).toBe(0);
+  });
+});