@accounter/server 0.0.8-alpha-20251102200443-d7162b8ce1dfc629b8b454df17dcec9ed005a052 → 0.0.8-alpha-20251103003648-f6467c8cb9c739ec4439c260bccc7325f6a761ae

package/src/modules/charges-matcher/__tests__/test-helpers.ts

@@ -0,0 +1,174 @@
+import type {
+  Transaction,
+  Document,
+  ChargeMatch,
+  AggregatedTransaction,
+  AggregatedDocument,
+  ConfidenceScores,
+} from '../types.js';
+import type { currency, document_type } from '@modules/documents/types.js';
+
+/**
+ * Factory for creating mock transactions for testing
+ */
+export function createMockTransaction(overrides: Partial<Transaction> = {}): Transaction {
+  const defaultTransaction: Transaction = {
+    id: `tx-${Math.random()}`,
+    account_id: 'account-1',
+    charge_id: 'charge-1',
+    source_id: 'source-1',
+    source_description: 'Test transaction',
+    currency: 'USD' as currency,
+    event_date: new Date('2024-01-15'),
+    debit_date: new Date('2024-01-16'),
+    debit_date_override: null,
+    debit_timestamp: new Date('2024-01-16T10:00:00Z'),
+    amount: '100.00',
+    current_balance: '1000.00',
+    business_id: 'business-a',
+    created_at: new Date('2024-01-15T08:00:00Z'),
+    updated_at: new Date('2024-01-15T08:00:00Z'),
+    is_fee: false,
+    counter_account: 'counter-1',
+    currency_rate: '1.0',
+    origin_key: 'test-origin',
+    source_origin: 'test-bank',
+    source_reference: 'test-ref-001',
+  };
+
+  return { ...defaultTransaction, ...overrides };
+}
+
+/**
+ * Factory for creating mock documents for testing
+ */
+export function createMockDocument(overrides: Partial<Document> = {}): Document {
+  const defaultDocument: Document = {
+    id: `doc-${Math.random()}`,
+    charge_id: 'charge-1',
+    creditor_id: 'business-a',
+    debtor_id: 'user-123',
+    currency_code: 'USD' as currency,
+    date: new Date('2024-01-14'),
+    total_amount: 100.0,
+    type: 'INVOICE' as document_type,
+    vat_amount: 17.0,
+    no_vat_amount: '83.00',
+    serial_number: 'INV-001',
+    is_reviewed: false,
+    created_at: new Date('2024-01-14T08:00:00Z'),
+    modified_at: new Date('2024-01-14T08:00:00Z'),
+    image_url: null,
+    file_url: null,
+    allocation_number: null,
+    exchange_rate_override: null,
+    file_hash: null,
+    vat_report_date_override: null,
+  };
+
+  return { ...defaultDocument, ...overrides };
+}
+
+/**
+ * Factory for creating mock aggregated transaction data
+ */
+export function createMockAggregatedTransaction(
+  overrides: Partial<AggregatedTransaction> = {},
+): AggregatedTransaction {
+  const defaultAggregated: AggregatedTransaction = {
+    amount: 100.0,
+    currency: 'USD' as currency,
+    businessId: 'business-a',
+    date: new Date('2024-01-15'),
+    debitDate: new Date('2024-01-16'),
+    description: 'Test transaction',
+  };
+
+  return { ...defaultAggregated, ...overrides };
+}
+
+/**
+ * Factory for creating mock aggregated document data
+ */
+export function createMockAggregatedDocument(
+  overrides: Partial<AggregatedDocument> = {},
+): AggregatedDocument {
+  const defaultAggregated: AggregatedDocument = {
+    amount: 100.0,
+    currency: 'USD' as currency,
+    businessId: 'business-a',
+    date: new Date('2024-01-14'),
+    description: 'INV-001',
+    type: 'INVOICE' as document_type,
+    businessIsCreditor: false,
+  };
+
+  return { ...defaultAggregated, ...overrides };
+}
+
+/**
+ * Factory for creating mock confidence scores
+ */
+export function createMockConfidenceScores(
+  overrides: Partial<ConfidenceScores> = {},
+): ConfidenceScores {
+  const defaultScores: ConfidenceScores = {
+    amount: 1.0,
+    currency: 1.0,
+    business: 1.0,
+    date: 1.0,
+  };
+
+  return { ...defaultScores, ...overrides };
+}
+
+/**
+ * Factory for creating mock charge matches
+ */
+export function createMockChargeMatch(overrides: Partial<ChargeMatch> = {}): ChargeMatch {
+  const defaultMatch: ChargeMatch = {
+    chargeId: '00000000-0000-0000-0000-000000000099',
+    confidenceScore: 0.95,
+  };
+
+  return { ...defaultMatch, ...overrides };
+}
+
+/**
+ * Helper to calculate expected overall confidence score
+ * Formula: (amount × 0.4) + (currency × 0.2) + (business × 0.3) + (date × 0.1)
+ */
+export function calculateExpectedConfidence(scores: ConfidenceScores): number {
+  return scores.amount * 0.4 + scores.currency * 0.2 + scores.business * 0.3 + scores.date * 0.1;
+}
+
+/**
+ * Helper to round confidence score to 2 decimal places
+ */
+export function roundConfidence(score: number): number {
+  return Math.round(score * 100) / 100;
+}
+
+/**
+ * Helper to validate a confidence score is within valid range
+ */
+export function isValidConfidenceScore(score: number): boolean {
+  return score >= 0.0 && score <= 1.0;
+}
+
+/**
+ * Helper to check if a date is within N days of another date
+ */
+export function isWithinDays(date1: Date, date2: Date, days: number): boolean {
+  const diffMs = Math.abs(date1.getTime() - date2.getTime());
+  const diffDays = diffMs / (1000 * 60 * 60 * 24);
+  return diffDays <= days;
+}
+
+/**
+ * Helper to calculate days difference between two dates
+ */
+export function daysDifference(date1: Date, date2: Date): number {
+  const diffMs = Math.abs(date1.getTime() - date2.getTime());
+  return Math.floor(diffMs / (1000 * 60 * 60 * 24));
+}

package/src/modules/charges-matcher/__tests__/test-infrastructure.spec.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect } from 'vitest';
+import {
+  createMockTransaction,
+  createMockDocument,
+  createMockAggregatedTransaction,
+  createMockAggregatedDocument,
+  createMockConfidenceScores,
+  calculateExpectedConfidence,
+  roundConfidence,
+  isValidConfidenceScore,
+  daysDifference,
+  isWithinDays,
+} from './test-helpers.js';
+
+describe('Charges Matcher - Test Infrastructure', () => {
+  describe('Mock Factories', () => {
+    it('should create a valid mock transaction with defaults', () => {
+      const transaction = createMockTransaction();
+
+      expect(transaction.id).toBeDefined();
+      expect(transaction.charge_id).toBeDefined();
+      expect(transaction.amount).toBe('100.00');
+      expect(transaction.currency).toBe('USD');
+      expect(transaction.is_fee).toBe(false);
+    });
+
+    it('should create a mock transaction with overrides', () => {
+      const transaction = createMockTransaction({
+        amount: '250.00',
+        currency: 'USD',
+        is_fee: true,
+      });
+
+      expect(transaction.amount).toBe('250.00');
+      expect(transaction.currency).toBe('USD');
+      expect(transaction.is_fee).toBe(true);
+    });
+
+    it('should create a valid mock document with defaults', () => {
+      const document = createMockDocument();
+
+      expect(document.id).toBeDefined();
+      expect(document.charge_id).toBeDefined();
+      expect(document.total_amount).toBe(100.0);
+      expect(document.currency_code).toBe('USD');
+      expect(document.type).toBe('INVOICE');
+    });
+
+    it('should create a mock document with overrides', () => {
+      const document = createMockDocument({
+        total_amount: 500.0,
+        type: 'RECEIPT',
+        serial_number: 'REC-123',
+      });
+
+      expect(document.total_amount).toBe(500.0);
+      expect(document.type).toBe('RECEIPT');
+      expect(document.serial_number).toBe('REC-123');
+    });
+
+    it('should create aggregated transaction data', () => {
+      const aggregated = createMockAggregatedTransaction({
+        amount: 150.0,
+        description: 'Payment for services',
+      });
+
+      expect(aggregated.amount).toBe(150.0);
+      expect(aggregated.description).toBe('Payment for services');
+    });
+
+    it('should create aggregated document data', () => {
+      const aggregated = createMockAggregatedDocument({
+        amount: 200.0,
+        businessIsCreditor: true,
+      });
+
+      expect(aggregated.amount).toBe(200.0);
+      expect(aggregated.businessIsCreditor).toBe(true);
+    });
+  });
+
+  describe('Confidence Calculation Helpers', () => {
+    it('should calculate expected confidence with perfect scores', () => {
+      const scores = createMockConfidenceScores({
+        amount: 1.0,
+        currency: 1.0,
+        business: 1.0,
+        date: 1.0,
+      });
+
+      const confidence = calculateExpectedConfidence(scores);
+      expect(confidence).toBeCloseTo(1.0, 10);
+    });
+
+    it('should calculate expected confidence with mixed scores', () => {
+      const scores = createMockConfidenceScores({
+        amount: 0.9, // 40% weight
+        currency: 1.0, // 20% weight
+        business: 0.5, // 30% weight
+        date: 0.8, // 10% weight
+      });
+
+      // (0.9 * 0.4) + (1.0 * 0.2) + (0.5 * 0.3) + (0.8 * 0.1)
+      // = 0.36 + 0.2 + 0.15 + 0.08 = 0.79
+      const confidence = calculateExpectedConfidence(scores);
+      expect(confidence).toBe(0.79);
+    });
+
+    it('should calculate expected confidence with zero scores', () => {
+      const scores = createMockConfidenceScores({
+        amount: 0.0,
+        currency: 0.0,
+        business: 0.0,
+        date: 0.0,
+      });
+
+      const confidence = calculateExpectedConfidence(scores);
+      expect(confidence).toBe(0.0);
+    });
+
+    it('should round confidence to 2 decimal places', () => {
+      expect(roundConfidence(0.956789)).toBe(0.96);
+      expect(roundConfidence(0.951)).toBe(0.95);
+      expect(roundConfidence(0.9)).toBe(0.9);
+      expect(roundConfidence(1.0)).toBe(1.0);
+    });
+
+    it('should validate confidence scores', () => {
+      expect(isValidConfidenceScore(0.0)).toBe(true);
+      expect(isValidConfidenceScore(0.5)).toBe(true);
+      expect(isValidConfidenceScore(1.0)).toBe(true);
+      expect(isValidConfidenceScore(-0.1)).toBe(false);
+      expect(isValidConfidenceScore(1.1)).toBe(false);
+    });
+  });
+
+  describe('Date Helpers', () => {
+    it('should calculate days difference correctly', () => {
+      const date1 = new Date('2024-01-15');
+      const date2 = new Date('2024-01-20');
+
+      expect(daysDifference(date1, date2)).toBe(5);
+    });
+
+    it('should handle same dates', () => {
+      const date = new Date('2024-01-15');
+
+      expect(daysDifference(date, date)).toBe(0);
+    });
+
+    it('should calculate difference regardless of order', () => {
+      const date1 = new Date('2024-01-15');
+      const date2 = new Date('2024-01-10');
+
+      expect(daysDifference(date1, date2)).toBe(5);
+      expect(daysDifference(date2, date1)).toBe(5);
+    });
+
+    it('should check if dates are within N days', () => {
+      const date1 = new Date('2024-01-15');
+      const date2 = new Date('2024-01-20');
+
+      expect(isWithinDays(date1, date2, 5)).toBe(true);
+      expect(isWithinDays(date1, date2, 4)).toBe(false);
+      expect(isWithinDays(date1, date2, 10)).toBe(true);
+    });
+
+    it('should handle 12-month window check', () => {
+      const date1 = new Date('2024-01-15');
+      const date2 = new Date('2024-12-15');
+      const date3 = new Date('2025-02-15');
+
+      expect(isWithinDays(date1, date2, 365)).toBe(true);
+      expect(isWithinDays(date1, date3, 365)).toBe(false);
+    });
+  });
+});