@open-mercato/core 0.4.5-develop-2e9903a57a → 0.4.5-develop-eeccf7adf4

package/src/modules/currencies/services/__tests__/rateFetchingService.basic.test.ts

@@ -1,398 +0,0 @@
-import { describe, it, expect, jest, beforeEach } from '@jest/globals'
-import { RateFetchingService } from '../rateFetchingService'
-import {
-  createMockEntityManager,
-  createMockProvider,
-  createTestCurrency,
-  createTestRate,
-  createTestExchangeRate,
-  TEST_SCOPE,
-  TEST_DATE,
-} from './rateFetchingService.setup'
-
-describe('RateFetchingService - Basic Functionality', () => {
-  let service: RateFetchingService
-  
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('successful fetch operations', () => {
-    it('fetches rates from all providers and returns aggregated results', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'PLN', name: 'Polish Zloty' }),
-        createTestCurrency({ code: 'EUR', name: 'Euro' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider1 = createMockProvider({
-        source: 'PROVIDER1',
-        rates: [createTestRate({ fromCurrencyCode: 'PLN', toCurrencyCode: 'EUR', source: 'PROVIDER1' })],
-      })
-      
-      const provider2 = createMockProvider({
-        source: 'PROVIDER2',
-        rates: [createTestRate({ fromCurrencyCode: 'EUR', toCurrencyCode: 'PLN', source: 'PROVIDER2' })],
-      })
-      
-      service.registerProvider(provider1)
-      service.registerProvider(provider2)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.totalFetched).toBe(2)
-      expect(result.byProvider['PROVIDER1']).toEqual({ count: 1 })
-      expect(result.byProvider['PROVIDER2']).toEqual({ count: 1 })
-      expect(result.errors).toEqual([])
-      expect(provider1.fetchRates).toHaveBeenCalledWith(TEST_DATE, TEST_SCOPE, new Set(['PLN', 'EUR']))
-      expect(provider2.fetchRates).toHaveBeenCalledWith(TEST_DATE, TEST_SCOPE, new Set(['PLN', 'EUR']))
-    })
-
-    it('stores fetched rates in database using transactions', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' })],
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(em.transactional).toHaveBeenCalled()
-    })
-
-    it('creates new exchange rates when they do not exist', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const testRate = createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR', rate: '0.92' })
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [testRate],
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert - create should be called within the transaction
-      expect(em.transactional).toHaveBeenCalled()
-    })
-
-    it('updates existing exchange rates when found', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const existingRate = createTestExchangeRate({
-        fromCurrencyCode: 'USD',
-        toCurrencyCode: 'EUR',
-        rate: '0.85',
-        date: TEST_DATE,
-        source: 'TEST',
-      })
-      
-      const { em } = createMockEntityManager({ currencies, existingRates: [existingRate] })
-      service = new RateFetchingService(em)
-      
-      const updatedRate = createTestRate({
-        fromCurrencyCode: 'USD',
-        toCurrencyCode: 'EUR',
-        rate: '0.92',
-        date: TEST_DATE,
-        source: 'TEST',
-      })
-      
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [updatedRate],
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.totalFetched).toBe(1)
-      expect(em.transactional).toHaveBeenCalled()
-    })
-
-    it('passes correct scope to provider fetchRates', async () => {
-      // Setup
-      const customScope = { tenantId: 'custom-tenant', organizationId: 'custom-org' }
-      const currencies = [
-        createTestCurrency({ 
-          code: 'USD',
-          tenantId: customScope.tenantId,
-          organizationId: customScope.organizationId,
-        }),
-      ]
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [],
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      await service.fetchRatesForDate(TEST_DATE, customScope)
-      
-      // Assert
-      expect(provider.fetchRates).toHaveBeenCalledWith(TEST_DATE, customScope, new Set(['USD']))
-    })
-  })
-
-  describe('currency filtering (critical)', () => {
-    it('only stores rates where both currencies exist and are active', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'PLN' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [
-          createTestRate({ fromCurrencyCode: 'PLN', toCurrencyCode: 'EUR' }), // Valid
-          createTestRate({ fromCurrencyCode: 'PLN', toCurrencyCode: 'USD' }), // USD not in DB
-          createTestRate({ fromCurrencyCode: 'EUR', toCurrencyCode: 'GBP' }), // GBP not in DB
-        ],
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert - only 1 rate should be stored (PLN→EUR)
-      expect(result.totalFetched).toBe(1)
-    })
-
-    it('filters out rates involving inactive currencies', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD', isActive: true }),
-        createTestCurrency({ code: 'EUR', isActive: false }), // Inactive
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [
-          createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' }),
-        ],
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert - EUR is inactive, so currency set should only contain USD
-      // The rate USD→EUR should be filtered out
-      expect(result.totalFetched).toBe(0)
-    })
-
-    it('filters out rates involving soft-deleted currencies', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD', deletedAt: null }),
-        createTestCurrency({ code: 'EUR', deletedAt: new Date() }), // Soft-deleted
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [
-          createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' }),
-        ],
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert - EUR is soft-deleted, so should be filtered
-      expect(result.totalFetched).toBe(0)
-    })
-
-    it('queries currencies with correct tenant and organization scope', async () => {
-      // Setup
-      const currencies = [createTestCurrency({ code: 'USD' })]
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({ source: 'TEST', rates: [] })
-      service.registerProvider(provider)
-      
-      const customScope = { tenantId: 'tenant-123', organizationId: 'org-456' }
-      
-      // Execute
-      await service.fetchRatesForDate(TEST_DATE, customScope)
-      
-      // Assert
-      expect(em.find).toHaveBeenCalledWith(
-        expect.anything(),
-        expect.objectContaining({
-          tenantId: 'tenant-123',
-          organizationId: 'org-456',
-          isActive: true,
-          deletedAt: null,
-        })
-      )
-    })
-
-    it('handles empty currency list gracefully', async () => {
-      // Setup - no currencies in database
-      const { em } = createMockEntityManager({ currencies: [] })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [createTestRate()],
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.totalFetched).toBe(0)
-      expect(result.errors).toEqual([])
-      expect(provider.fetchRates).toHaveBeenCalledWith(TEST_DATE, TEST_SCOPE, new Set([]))
-    })
-  })
-
-  describe('result structure', () => {
-    it('returns correct totalFetched count', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-        createTestCurrency({ code: 'GBP' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider1 = createMockProvider({
-        source: 'PROVIDER1',
-        rates: [
-          createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' }),
-          createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'GBP' }),
-        ],
-      })
-      
-      const provider2 = createMockProvider({
-        source: 'PROVIDER2',
-        rates: [
-          createTestRate({ fromCurrencyCode: 'EUR', toCurrencyCode: 'USD' }),
-          createTestRate({ fromCurrencyCode: 'GBP', toCurrencyCode: 'USD' }),
-        ],
-      })
-      
-      service.registerProvider(provider1)
-      service.registerProvider(provider2)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.totalFetched).toBe(4)
-    })
-
-    it('returns per-provider counts in byProvider', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider1 = createMockProvider({
-        source: 'SOURCE1',
-        rates: [
-          createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' }),
-          createTestRate({ fromCurrencyCode: 'EUR', toCurrencyCode: 'USD' }),
-        ],
-      })
-      
-      const provider2 = createMockProvider({
-        source: 'SOURCE2',
-        rates: [
-          createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' }),
-        ],
-      })
-      
-      service.registerProvider(provider1)
-      service.registerProvider(provider2)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.byProvider['SOURCE1']).toEqual({ count: 2 })
-      expect(result.byProvider['SOURCE2']).toEqual({ count: 1 })
-    })
-
-    it('returns empty errors array when all succeed', async () => {
-      // Setup
-      const currencies = [createTestCurrency({ code: 'USD' })]
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [],
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.errors).toEqual([])
-    })
-  })
-})

package/src/modules/currencies/services/__tests__/rateFetchingService.errors.test.ts

@@ -1,296 +0,0 @@
-import { describe, it, expect, jest, beforeEach } from '@jest/globals'
-import { RateFetchingService } from '../rateFetchingService'
-import {
-  createMockEntityManager,
-  createMockProvider,
-  createTestCurrency,
-  createTestRate,
-  TEST_SCOPE,
-  TEST_DATE,
-} from './rateFetchingService.setup'
-
-describe('RateFetchingService - Error Handling', () => {
-  let service: RateFetchingService
-  
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('provider errors', () => {
-    it('catches provider fetch errors and continues with other providers', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const failingProvider = createMockProvider({
-        source: 'FAILING',
-        error: new Error('Network timeout'),
-      })
-      
-      const successProvider = createMockProvider({
-        source: 'SUCCESS',
-        rates: [createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' })],
-      })
-      
-      service.registerProvider(failingProvider)
-      service.registerProvider(successProvider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.totalFetched).toBe(1) // Only from success provider
-      expect(result.byProvider['SUCCESS']).toEqual({ count: 1 })
-      expect(result.errors).toContain('FAILING: Network timeout')
-      expect(successProvider.fetchRates).toHaveBeenCalled()
-    })
-
-    it('records provider-specific errors in byProvider', async () => {
-      // Setup
-      const currencies = [createTestCurrency({ code: 'USD' })]
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'ERROR_SOURCE',
-        error: new Error('API rate limit exceeded'),
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.byProvider['ERROR_SOURCE']).toEqual({
-        count: 0,
-        errors: ['API rate limit exceeded'],
-      })
-      expect(result.errors).toContain('ERROR_SOURCE: API rate limit exceeded')
-    })
-
-    it('sets count to 0 for providers that fail', async () => {
-      // Setup
-      const currencies = [createTestCurrency({ code: 'USD' })]
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'FAILED',
-        error: new Error('Connection refused'),
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.byProvider['FAILED'].count).toBe(0)
-      expect(result.totalFetched).toBe(0)
-    })
-
-    it('includes both provider errors and general errors in result', async () => {
-      // Setup
-      const currencies = [createTestCurrency({ code: 'USD' })]
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const failingProvider = createMockProvider({
-        source: 'FAILING',
-        error: new Error('Provider error'),
-      })
-      
-      service.registerProvider(failingProvider)
-      
-      // Execute - also request an unknown provider
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE, {
-        providers: ['UNKNOWN', 'FAILING'],
-      })
-      
-      // Assert
-      expect(result.errors).toContain('Unknown provider: UNKNOWN')
-      expect(result.errors).toContain('FAILING: Provider error')
-      expect(result.errors.length).toBe(2)
-    })
-  })
-
-  describe('edge cases', () => {
-    it('handles empty currency list gracefully', async () => {
-      // Setup - no currencies in database
-      const { em } = createMockEntityManager({ currencies: [] })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [createTestRate()],
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.totalFetched).toBe(0)
-      expect(result.errors).toEqual([])
-      // Provider should still be called, just with empty currency set
-      expect(provider.fetchRates).toHaveBeenCalledWith(TEST_DATE, TEST_SCOPE, new Set([]))
-    })
-
-    it('handles providers returning empty arrays', async () => {
-      // Setup
-      const currencies = [createTestCurrency({ code: 'USD' })]
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'EMPTY',
-        rates: [], // Returns no rates
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.totalFetched).toBe(0)
-      expect(result.byProvider['EMPTY']).toEqual({ count: 0 })
-      expect(result.errors).toEqual([])
-    })
-
-    it('handles date objects correctly', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' })],
-      })
-      
-      service.registerProvider(provider)
-      
-      const testDate = new Date('2024-03-15T14:30:00.000Z')
-      
-      // Execute
-      await service.fetchRatesForDate(testDate, TEST_SCOPE)
-      
-      // Assert
-      expect(provider.fetchRates).toHaveBeenCalledWith(testDate, TEST_SCOPE, expect.any(Set))
-    })
-
-    it('stores rates with correct scope information', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' })],
-      })
-      
-      service.registerProvider(provider)
-      
-      const customScope = { tenantId: 'tenant-abc', organizationId: 'org-xyz' }
-      
-      // Execute
-      await service.fetchRatesForDate(TEST_DATE, customScope)
-      
-      // Assert - verify transactional was called (rates stored with scope)
-      expect(em.transactional).toHaveBeenCalled()
-    })
-
-    it('handles multiple rates from same provider correctly', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-        createTestCurrency({ code: 'GBP' }),
-        createTestCurrency({ code: 'CHF' }),
-      ]
-      
-      const { em } = createMockEntityManager({ currencies })
-      service = new RateFetchingService(em)
-      
-      // Provider returns many rates
-      const rates = [
-        createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' }),
-        createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'GBP' }),
-        createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'CHF' }),
-        createTestRate({ fromCurrencyCode: 'EUR', toCurrencyCode: 'USD' }),
-        createTestRate({ fromCurrencyCode: 'EUR', toCurrencyCode: 'GBP' }),
-        createTestRate({ fromCurrencyCode: 'EUR', toCurrencyCode: 'CHF' }),
-        createTestRate({ fromCurrencyCode: 'GBP', toCurrencyCode: 'USD' }),
-        createTestRate({ fromCurrencyCode: 'GBP', toCurrencyCode: 'EUR' }),
-        createTestRate({ fromCurrencyCode: 'CHF', toCurrencyCode: 'USD' }),
-        createTestRate({ fromCurrencyCode: 'CHF', toCurrencyCode: 'EUR' }),
-      ]
-      
-      const provider = createMockProvider({
-        source: 'MULTI',
-        rates,
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert
-      expect(result.totalFetched).toBe(10)
-      expect(result.byProvider['MULTI']).toEqual({ count: 10 })
-    })
-  })
-
-  describe('database errors', () => {
-    it('catches transaction errors and includes them in result', async () => {
-      // Setup
-      const currencies = [
-        createTestCurrency({ code: 'USD' }),
-        createTestCurrency({ code: 'EUR' }),
-      ]
-      
-      const { em } = createMockEntityManager({
-        currencies,
-        shouldFailTransaction: true,
-      })
-      
-      service = new RateFetchingService(em)
-      
-      const provider = createMockProvider({
-        source: 'TEST',
-        rates: [createTestRate({ fromCurrencyCode: 'USD', toCurrencyCode: 'EUR' })],
-      })
-      
-      service.registerProvider(provider)
-      
-      // Execute
-      const result = await service.fetchRatesForDate(TEST_DATE, TEST_SCOPE)
-      
-      // Assert - transaction error should be caught and included in errors
-      expect(result.totalFetched).toBe(0)
-      expect(result.errors).toContain('TEST: Transaction failed')
-      expect(result.byProvider['TEST']).toEqual({
-        count: 0,
-        errors: ['Transaction failed'],
-      })
-    })
-  })
-})