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

package/src/modules/charges-matcher/__tests__/charge-validator.test.ts

@@ -0,0 +1,374 @@
+import { describe, expect, it } from 'vitest';
+import {
+  validateChargeForMatching,
+  validateChargeIsUnmatched,
+  isChargeMatched,
+  hasOnlyTransactions,
+  hasOnlyDocuments,
+} from '../helpers/charge-validator.helper.js';
+import { createMockTransaction, createMockDocument } from './test-helpers.js';
+
+describe('Charge Validator', () => {
+  describe('validateChargeForMatching', () => {
+    it('should pass for charge with transactions', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [],
+      };
+
+      expect(() => validateChargeForMatching(charge)).not.toThrow();
+    });
+
+    it('should pass for charge with documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'INVOICE' })],
+      };
+
+      expect(() => validateChargeForMatching(charge)).not.toThrow();
+    });
+
+    it('should pass for charge with both transactions and documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'INVOICE' })],
+      };
+
+      expect(() => validateChargeForMatching(charge)).not.toThrow();
+    });
+
+    it('should throw if charge is null', () => {
+      expect(() => validateChargeForMatching(null as any)).toThrow('Charge is required');
+    });
+
+    it('should throw if charge is undefined', () => {
+      expect(() => validateChargeForMatching(undefined as any)).toThrow('Charge is required');
+    });
+
+    it('should throw if charge has no ID', () => {
+      const charge = {
+        id: '',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction()],
+        documents: [],
+      };
+
+      expect(() => validateChargeForMatching(charge)).toThrow('Charge must have an ID');
+    });
+
+    it('should throw if charge has no owner_id', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: null,
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [],
+      };
+
+      expect(() => validateChargeForMatching(charge)).toThrow('must have an owner_id');
+    });
+
+    it('should throw if charge has no transactions and no documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [],
+        documents: [],
+      };
+
+      expect(() => validateChargeForMatching(charge)).toThrow(
+        'has no transactions or documents',
+      );
+    });
+
+    it('should throw if charge has undefined transactions and documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: undefined,
+        documents: undefined,
+      };
+
+      expect(() => validateChargeForMatching(charge)).toThrow(
+        'has no transactions or documents',
+      );
+    });
+  });
+
+  describe('isChargeMatched', () => {
+    it('should return true for charge with transactions and accounting documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'INVOICE' })],
+      };
+
+      expect(isChargeMatched(charge)).toBe(true);
+    });
+
+    it('should return true for charge with CREDIT_INVOICE', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'CREDIT_INVOICE' })],
+      };
+
+      expect(isChargeMatched(charge)).toBe(true);
+    });
+
+    it('should return true for charge with RECEIPT', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'RECEIPT' })],
+      };
+
+      expect(isChargeMatched(charge)).toBe(true);
+    });
+
+    it('should return true for charge with INVOICE_RECEIPT', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'INVOICE_RECEIPT' })],
+      };
+
+      expect(isChargeMatched(charge)).toBe(true);
+    });
+
+    it('should return false for charge with only transactions', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [],
+      };
+
+      expect(isChargeMatched(charge)).toBe(false);
+    });
+
+    it('should return false for charge with only documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'INVOICE' })],
+      };
+
+      expect(isChargeMatched(charge)).toBe(false);
+    });
+
+    it('should return false for charge with transactions and PROFORMA (non-accounting doc)', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'PROFORMA' })],
+      };
+
+      expect(isChargeMatched(charge)).toBe(false);
+    });
+
+    it('should return false for charge with transactions and OTHER (non-accounting doc)', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'OTHER' })],
+      };
+
+      expect(isChargeMatched(charge)).toBe(false);
+    });
+
+    it('should return false for charge with transactions and UNPROCESSED (non-accounting doc)', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'UNPROCESSED' })],
+      };
+
+      expect(isChargeMatched(charge)).toBe(false);
+    });
+  });
+
+  describe('hasOnlyTransactions', () => {
+    it('should return true for charge with only transactions', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [],
+      };
+
+      expect(hasOnlyTransactions(charge)).toBe(true);
+    });
+
+    it('should return true for charge with transactions and non-accounting documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'PROFORMA' })],
+      };
+
+      expect(hasOnlyTransactions(charge)).toBe(true);
+    });
+
+    it('should return false for charge with transactions and accounting documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'INVOICE' })],
+      };
+
+      expect(hasOnlyTransactions(charge)).toBe(false);
+    });
+
+    it('should return false for charge with only documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'INVOICE' })],
+      };
+
+      expect(hasOnlyTransactions(charge)).toBe(false);
+    });
+
+    it('should return false for charge with no data', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [],
+        documents: [],
+      };
+
+      expect(hasOnlyTransactions(charge)).toBe(false);
+    });
+  });
+
+  describe('hasOnlyDocuments', () => {
+    it('should return true for charge with only accounting documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'INVOICE' })],
+      };
+
+      expect(hasOnlyDocuments(charge)).toBe(true);
+    });
+
+    it('should return true for charge with CREDIT_INVOICE', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'CREDIT_INVOICE' })],
+      };
+
+      expect(hasOnlyDocuments(charge)).toBe(true);
+    });
+
+    it('should return false for charge with only non-accounting documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'PROFORMA' })],
+      };
+
+      expect(hasOnlyDocuments(charge)).toBe(false);
+    });
+
+    it('should return false for charge with transactions and documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'INVOICE' })],
+      };
+
+      expect(hasOnlyDocuments(charge)).toBe(false);
+    });
+
+    it('should return false for charge with only transactions', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [],
+      };
+
+      expect(hasOnlyDocuments(charge)).toBe(false);
+    });
+
+    it('should return false for charge with no data', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [],
+        documents: [],
+      };
+
+      expect(hasOnlyDocuments(charge)).toBe(false);
+    });
+  });
+
+  describe('validateChargeIsUnmatched', () => {
+    it('should pass for charge with only transactions', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [],
+      };
+
+      expect(() => validateChargeIsUnmatched(charge)).not.toThrow();
+    });
+
+    it('should pass for charge with only documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'INVOICE' })],
+      };
+
+      expect(() => validateChargeIsUnmatched(charge)).not.toThrow();
+    });
+
+    it('should throw for charge with both transactions and accounting documents', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: 'user-1',
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [createMockDocument({ charge_id: 'charge-1', type: 'INVOICE' })],
+      };
+
+      expect(() => validateChargeIsUnmatched(charge)).toThrow('is already matched');
+    });
+
+    it('should propagate validation errors', () => {
+      const charge = {
+        id: 'charge-1',
+        owner_id: null,
+        transactions: [createMockTransaction({ charge_id: 'charge-1' })],
+        documents: [],
+      };
+
+      expect(() => validateChargeIsUnmatched(charge)).toThrow('must have an owner_id');
+    });
+  });
+});

package/src/modules/charges-matcher/__tests__/currency-confidence.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect } from 'vitest';
+import { calculateCurrencyConfidence } from '../helpers/currency-confidence.helper.js';
+
+describe('calculateCurrencyConfidence', () => {
+  describe('same currency', () => {
+    it('should return 1.0 for identical USD', () => {
+      expect(calculateCurrencyConfidence('USD', 'USD')).toBe(1.0);
+    });
+
+    it('should return 1.0 for identical EUR', () => {
+      expect(calculateCurrencyConfidence('EUR', 'EUR')).toBe(1.0);
+    });
+
+    it('should return 1.0 for identical ILS', () => {
+      expect(calculateCurrencyConfidence('ILS', 'ILS')).toBe(1.0);
+    });
+
+    it('should return 1.0 for identical GBP', () => {
+      expect(calculateCurrencyConfidence('GBP', 'GBP')).toBe(1.0);
+    });
+
+    it('should return 1.0 for identical USDC', () => {
+      expect(calculateCurrencyConfidence('USDC', 'USDC')).toBe(1.0);
+    });
+
+    it('should return 1.0 for identical GRT', () => {
+      expect(calculateCurrencyConfidence('GRT', 'GRT')).toBe(1.0);
+    });
+
+    it('should return 1.0 for identical ETH', () => {
+      expect(calculateCurrencyConfidence('ETH', 'ETH')).toBe(1.0);
+    });
+  });
+
+  describe('different currencies', () => {
+    it('should return 0.0 for USD vs EUR', () => {
+      expect(calculateCurrencyConfidence('USD', 'EUR')).toBe(0.0);
+    });
+
+    it('should return 0.0 for ILS vs USD', () => {
+      expect(calculateCurrencyConfidence('ILS', 'USD')).toBe(0.0);
+    });
+
+    it('should return 0.0 for EUR vs GBP', () => {
+      expect(calculateCurrencyConfidence('EUR', 'GBP')).toBe(0.0);
+    });
+
+    it('should return 0.0 for GRT vs ETH', () => {
+      expect(calculateCurrencyConfidence('GRT', 'ETH')).toBe(0.0);
+    });
+
+    it('should return 0.0 for USDC vs USD', () => {
+      expect(calculateCurrencyConfidence('USDC', 'USD')).toBe(0.0);
+    });
+  });
+
+  describe('case sensitivity', () => {
+    it('should be case-insensitive for uppercase vs lowercase', () => {
+      expect(calculateCurrencyConfidence('USD', 'usd')).toBe(1.0);
+    });
+
+    it('should be case-insensitive for lowercase vs uppercase', () => {
+      expect(calculateCurrencyConfidence('eur', 'EUR')).toBe(1.0);
+    });
+
+    it('should be case-insensitive for mixed case', () => {
+      expect(calculateCurrencyConfidence('Usd', 'UsD')).toBe(1.0);
+    });
+
+    it('should be case-insensitive for ILS variations', () => {
+      expect(calculateCurrencyConfidence('ILS', 'ils')).toBe(1.0);
+      expect(calculateCurrencyConfidence('ils', 'ILS')).toBe(1.0);
+    });
+  });
+
+  describe('edge cases with null and undefined', () => {
+    it('should return 0.2 when transaction currency is null', () => {
+      expect(calculateCurrencyConfidence(null, 'USD')).toBe(0.2);
+    });
+
+    it('should return 0.2 when document currency is null', () => {
+      expect(calculateCurrencyConfidence('USD', null)).toBe(0.2);
+    });
+
+    it('should return 0.2 when both currencies are null', () => {
+      expect(calculateCurrencyConfidence(null, null)).toBe(0.2);
+    });
+
+    it('should return 0.2 when transaction currency is undefined', () => {
+      expect(calculateCurrencyConfidence(undefined, 'USD')).toBe(0.2);
+    });
+
+    it('should return 0.2 when document currency is undefined', () => {
+      expect(calculateCurrencyConfidence('USD', undefined)).toBe(0.2);
+    });
+
+    it('should return 0.2 when both currencies are undefined', () => {
+      expect(calculateCurrencyConfidence(undefined, undefined)).toBe(0.2);
+    });
+
+    it('should return 0.2 when transaction is null and document is undefined', () => {
+      expect(calculateCurrencyConfidence(null, undefined)).toBe(0.2);
+    });
+
+    it('should return 0.2 when transaction is undefined and document is null', () => {
+      expect(calculateCurrencyConfidence(undefined, null)).toBe(0.2);
+    });
+  });
+
+  describe('edge cases with empty strings', () => {
+    it('should return 0.2 when transaction currency is empty string', () => {
+      expect(calculateCurrencyConfidence('', 'USD')).toBe(0.2);
+    });
+
+    it('should return 0.2 when document currency is empty string', () => {
+      expect(calculateCurrencyConfidence('USD', '')).toBe(0.2);
+    });
+
+    it('should return 0.2 when both currencies are empty strings', () => {
+      expect(calculateCurrencyConfidence('', '')).toBe(0.2);
+    });
+  });
+
+  describe('symmetry', () => {
+    it('should return same result regardless of parameter order for same currencies', () => {
+      expect(calculateCurrencyConfidence('USD', 'EUR')).toBe(
+        calculateCurrencyConfidence('EUR', 'USD'),
+      );
+    });
+
+    it('should return same result regardless of parameter order for matching currencies', () => {
+      expect(calculateCurrencyConfidence('USD', 'USD')).toBe(
+        calculateCurrencyConfidence('USD', 'USD'),
+      );
+    });
+  });
+
+  describe('return value validation', () => {
+    it('should return exactly 1.0, 0.2, or 0.0 (no other values)', () => {
+      const result1 = calculateCurrencyConfidence('USD', 'USD');
+      const result2 = calculateCurrencyConfidence('USD', 'EUR');
+      const result3 = calculateCurrencyConfidence(null, 'USD');
+
+      expect([1.0, 0.2, 0.0]).toContain(result1);
+      expect([1.0, 0.2, 0.0]).toContain(result2);
+      expect([1.0, 0.2, 0.0]).toContain(result3);
+    });
+
+    it('should return numbers with correct precision', () => {
+      const match = calculateCurrencyConfidence('USD', 'USD');
+      const mismatch = calculateCurrencyConfidence('USD', 'EUR');
+      const missing = calculateCurrencyConfidence(null, 'USD');
+
+      expect(match).toBe(1.0);
+      expect(mismatch).toBe(0.0);
+      expect(missing).toBe(0.2);
+
+      // Verify exact values
+      expect(match === 1.0).toBe(true);
+      expect(mismatch === 0.0).toBe(true);
+      expect(missing === 0.2).toBe(true);
+    });
+  });
+});