4NK_IA_front/tests/collectors.test.js

/**
 * Tests des collecteurs de données externes
 */

import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
import { 
  mockBodaccResponse, 
  mockCompanyResponse, 
  mockRBEResponse, 
  mockGeofoncierResponse, 
  mockAddressResponse,
  createErrorMock,
  delay 
} from './mocks/external-apis.js'

let searchBodaccGelAvoirs, searchCompanyInfo, searchRBEBeneficiaires, searchGeofoncierInfo, collectAddressData
beforeEach(async () => {
  const bodaccModule = await import('../backend/collectors/bodaccCollector.js')
  const inforgreffeModule = await import('../backend/collectors/inforgreffeCollector.js')
  const rbeModule = await import('../backend/collectors/rbeCollector.js')
  const geofoncierModule = await import('../backend/collectors/geofoncierCollector.js')
  const addressModule = await import('../backend/collectors/addressCollector.js')
  
  searchBodaccGelAvoirs = bodaccModule.searchBodaccGelAvoirs
  searchCompanyInfo = inforgreffeModule.searchCompanyInfo
  searchRBEBeneficiaires = rbeModule.searchRBEBeneficiaires
  searchGeofoncierInfo = geofoncierModule.searchGeofoncierInfo
  collectAddressData = addressModule.collectAddressData
})

describe('Collecteurs de données externes', () => {
  beforeEach(() => {
    // Mock des timeouts pour les tests
    vi.useFakeTimers()
  })

  afterEach(() => {
    vi.useRealTimers()
  })

  describe('Bodacc Collector', () => {
    it('devrait rechercher des informations de gel des avoirs', async () => {
      const result = await searchBodaccGelAvoirs('DUPONT', 'Jean')

      expect(result).toHaveProperty('success')
      expect(result).toHaveProperty('duration')
      expect(result).toHaveProperty('nom', 'DUPONT')
      expect(result).toHaveProperty('prenom', 'Jean')
      expect(result).toHaveProperty('timestamp')

      if (result.success) {
        expect(result).toHaveProperty('results')
        expect(Array.isArray(result.results)).toBe(true)
      }
    })

    it('devrait gérer les erreurs de recherche', async () => {
      // Test avec un nom invalide
      const result = await searchBodaccGelAvoirs('', '')

      expect(result).toHaveProperty('success', false)
      expect(result).toHaveProperty('error')
    })
  })

  describe('Inforgreffe Collector', () => {
    it('devrait rechercher des informations d\'entreprise', async () => {
      const result = await searchCompanyInfo('MICROSOFT FRANCE')

      expect(result).toHaveProperty('success')
      expect(result).toHaveProperty('duration')
      expect(result).toHaveProperty('company')
      expect(result).toHaveProperty('sources')
      expect(result).toHaveProperty('timestamp')

      if (result.success) {
        expect(result.company).toHaveProperty('name')
        expect(result.sources).toHaveProperty('societeCom')
      }
    })

    it('devrait gérer les entreprises inexistantes', async () => {
      const result = await searchCompanyInfo('ENTREPRISE_INEXISTANTE_12345')

      expect(result).toHaveProperty('success')
      // Peut être true avec des données vides ou false selon l'implémentation
    })
  })

  describe('RBE Collector', () => {
    it('devrait rechercher les bénéficiaires effectifs', async () => {
      const result = await searchRBEBeneficiaires('123456789')

      expect(result).toHaveProperty('success')
      expect(result).toHaveProperty('duration')
      expect(result).toHaveProperty('siren', '123456789')
      expect(result).toHaveProperty('beneficiaires')
      expect(result).toHaveProperty('timestamp')

      if (result.success) {
        expect(Array.isArray(result.beneficiaires)).toBe(true)
      }
    })

    it('devrait valider le format du SIREN', async () => {
      const result = await searchRBEBeneficiaires('123')

      expect(result).toHaveProperty('success', false)
      expect(result).toHaveProperty('error')
      expect(result.error).toContain('SIREN invalide')
    })
  })

  describe('GéoFoncier Collector', () => {
    it('devrait rechercher des informations foncières', async () => {
      const address = {
        street: '1 rue de la Paix',
        city: 'Paris',
        postalCode: '75001',
        country: 'France'
      }

      const result = await searchGeofoncierInfo(address)

      expect(result).toHaveProperty('success')
      expect(result).toHaveProperty('duration')
      expect(result).toHaveProperty('address')
      expect(result).toHaveProperty('timestamp')

      if (result.success) {
        expect(result).toHaveProperty('geocode')
        expect(result).toHaveProperty('parcelles')
        expect(result).toHaveProperty('infoFonciere')
        expect(result).toHaveProperty('mutations')
      }
    })

    it('devrait gérer les adresses invalides', async () => {
      const address = {
        street: '',
        city: '',
        postalCode: '',
        country: ''
      }

      const result = await searchGeofoncierInfo(address)

      expect(result).toHaveProperty('success')
      // Peut être false si géocodage échoue
    })
  })

  describe('Address Collector', () => {
    it('devrait géocoder une adresse via BAN', async () => {
      const address = {
        street: '1 rue de la Paix',
        city: 'Paris',
        postalCode: '75001',
        country: 'France'
      }

      const result = await collectAddressData(address)

      expect(result).toHaveProperty('success')
      expect(result).toHaveProperty('geocode')
      expect(result).toHaveProperty('risks')
      expect(result).toHaveProperty('cadastre')
      expect(result).toHaveProperty('timestamp')
      expect(result).toHaveProperty('sources')

      if (result.success) {
        expect(result.geocode).toHaveProperty('success')
        expect(Array.isArray(result.risks)).toBe(true)
        expect(Array.isArray(result.cadastre)).toBe(true)
        expect(result.sources).toContain('ban')
        expect(result.sources).toContain('georisque')
        expect(result.sources).toContain('cadastre')
      }
    })

    it('devrait gérer les adresses non trouvées', async () => {
      const address = {
        street: 'Adresse Inexistante 99999',
        city: 'Ville Inexistante',
        postalCode: '99999',
        country: 'France'
      }

      const result = await collectAddressData(address)

      expect(result).toHaveProperty('success')
      // Peut être false si géocodage échoue
    })
  })

  describe('Performance des collecteurs', () => {
    it('devrait respecter les timeouts', async () => {
      const startTime = Date.now()

      // Test avec un nom qui pourrait prendre du temps
      const result = await searchBodaccGelAvoirs('SMITH', 'John')

      const duration = Date.now() - startTime

      expect(duration).toBeLessThan(15000) // 15 secondes max
      expect(result).toHaveProperty('duration')
      expect(result.duration).toBeLessThan(15000)
    })

    it('devrait gérer les erreurs de réseau', async () => {
      // Mock d'une erreur de réseau
      const originalFetch = global.fetch
      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'))

      try {
        const result = await searchCompanyInfo('TEST COMPANY')
        expect(result).toHaveProperty('success', false)
        expect(result).toHaveProperty('error')
      } finally {
        global.fetch = originalFetch
      }
    })
  })

  describe('Validation des données', () => {
    it('devrait valider les formats de réponse', async () => {
      const result = await searchBodaccGelAvoirs('DUPONT', 'Jean')

      // Vérification de la structure de base
      expect(typeof result.success).toBe('boolean')
      expect(typeof result.duration).toBe('number')
      expect(result.duration).toBeGreaterThan(0)
      expect(typeof result.timestamp).toBe('string')

      // Vérification du format de timestamp
      expect(() => new Date(result.timestamp)).not.toThrow()
    })

    it('devrait inclure les métadonnées de source', async () => {
      const result = await collectAddressData({
        street: '1 rue de la Paix',
        city: 'Paris',
        postalCode: '75001',
        country: 'France'
      })

      if (result.success) {
        expect(result).toHaveProperty('sources')
        expect(Array.isArray(result.sources)).toBe(true)
        expect(result.sources.length).toBeGreaterThan(0)
      }
    })
  })
})