436 lines
15 KiB
TypeScript
436 lines
15 KiB
TypeScript
import { beforeEach, describe, expect, it, vi } from 'vitest'
|
|
|
|
// ---------- Prisma mockeado (los tests no tocan la BD) ----------
|
|
|
|
const prismaMock = vi.hoisted(() => ({
|
|
cliente: {
|
|
findFirst: vi.fn(),
|
|
findMany: vi.fn(),
|
|
},
|
|
leadCaptura: {
|
|
findUnique: vi.fn(),
|
|
findMany: vi.fn(),
|
|
},
|
|
cotizacion: {
|
|
findMany: vi.fn(),
|
|
},
|
|
documento: {
|
|
findMany: vi.fn(),
|
|
},
|
|
usuario: {
|
|
findMany: vi.fn(),
|
|
},
|
|
}))
|
|
|
|
vi.mock('../services/prisma.js', () => ({ prisma: prismaMock }))
|
|
|
|
import { detalleContactoLocal, listarContactosLocal } from './contactos-local.service.js'
|
|
|
|
function clienteFake(parcial: Record<string, unknown> & { id: string }) {
|
|
return {
|
|
nombreCompleto: `Cliente ${parcial.id}`,
|
|
curp: 'CURP123',
|
|
rfc: 'RFC123',
|
|
email: null,
|
|
celular: null,
|
|
proyecto: '',
|
|
unidadCodigo: null,
|
|
payloadJson: '{}',
|
|
mondayContactoId: null,
|
|
mondayApartadoId: null,
|
|
capturadoPorId: null,
|
|
createdAt: new Date('2026-09-01T10:00:00'),
|
|
...parcial,
|
|
}
|
|
}
|
|
|
|
function capturaFake(parcial: Record<string, unknown> & { leadId: string }) {
|
|
return {
|
|
id: `row-${parcial.leadId}`,
|
|
nombreLead: `Persona ${parcial.leadId}`,
|
|
telefono: null,
|
|
email: null,
|
|
origen: null,
|
|
desarrollo: null,
|
|
modelo: null,
|
|
board: 'OPORTUNIDADES',
|
|
etapa: 'Afluencia',
|
|
usuarioId: 'u-1',
|
|
datosJson: null,
|
|
mondayItemId: null,
|
|
pendienteSync: true,
|
|
createdAt: new Date('2026-09-02T10:00:00'),
|
|
updatedAt: new Date('2026-09-03T10:00:00'),
|
|
...parcial,
|
|
}
|
|
}
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
prismaMock.cliente.findMany.mockResolvedValue([])
|
|
prismaMock.cliente.findFirst.mockResolvedValue(null)
|
|
prismaMock.leadCaptura.findUnique.mockResolvedValue(null)
|
|
prismaMock.leadCaptura.findMany.mockResolvedValue([])
|
|
prismaMock.cotizacion.findMany.mockResolvedValue([])
|
|
prismaMock.documento.findMany.mockResolvedValue([])
|
|
prismaMock.usuario.findMany.mockResolvedValue([{ id: 'u-1', nombre: 'Martin Zavala' }])
|
|
})
|
|
|
|
describe('listarContactosLocal', () => {
|
|
it('arma la lista desde Cliente + capturas (OPORTUNIDADES/APARTADO) con fuente local', async () => {
|
|
prismaMock.cliente.findMany.mockResolvedValue([
|
|
clienteFake({ id: 'c1', nombreCompleto: 'JUAN PÉREZ', celular: '4771234567', email: 'juan@correo.mx', proyecto: 'SENDA' }),
|
|
])
|
|
prismaMock.leadCaptura.findMany.mockResolvedValue([
|
|
capturaFake({ leadId: 'loc_1', nombreLead: 'ANA DEMO', telefono: '6649998877', etapa: 'Pago Apartado', board: 'APARTADO' }),
|
|
])
|
|
|
|
const lista = (await listarContactosLocal()).contactos
|
|
|
|
expect(lista).toHaveLength(2)
|
|
expect(lista[0]).toMatchObject({
|
|
id: 'loc_1', // updatedAt más reciente primero
|
|
nombre: 'ANA DEMO',
|
|
telefono: '6649998877',
|
|
estado: 'Pago Apartado',
|
|
fuente: 'local',
|
|
})
|
|
expect(lista[1]).toMatchObject({
|
|
id: 'c1',
|
|
nombre: 'JUAN PÉREZ',
|
|
telefono: '4771234567',
|
|
email: 'juan@correo.mx',
|
|
estado: 'Cliente',
|
|
fuente: 'local',
|
|
})
|
|
})
|
|
|
|
it('deduplica por teléfono (gana el Cliente: tiene la ficha completa)', async () => {
|
|
prismaMock.cliente.findMany.mockResolvedValue([
|
|
clienteFake({ id: 'c1', celular: '+52 477 123 4567' }),
|
|
])
|
|
prismaMock.leadCaptura.findMany.mockResolvedValue([
|
|
capturaFake({ leadId: 'loc_1', telefono: '4771234567' }),
|
|
])
|
|
|
|
const lista = (await listarContactosLocal()).contactos
|
|
expect(lista).toHaveLength(1)
|
|
expect(lista[0]?.id).toBe('c1')
|
|
})
|
|
|
|
it('deduplica por nombre a los registros sin teléfono ni email (gana la ficha con más datos)', async () => {
|
|
// Alta fallida: Cliente hueco (payload vacío, sin teléfono ni email) con el
|
|
// mismo nombre que su ficha real
|
|
prismaMock.cliente.findMany.mockResolvedValue([
|
|
clienteFake({
|
|
id: 'hueco',
|
|
nombreCompleto: 'LUIS ENRIQUE SALGADO ZAVALETA',
|
|
payloadJson: '{}',
|
|
createdAt: new Date('2026-09-11T10:00:00'),
|
|
}),
|
|
clienteFake({
|
|
id: 'completo',
|
|
nombreCompleto: 'Luis Enrique Salgado Zavaleta',
|
|
celular: '+52 5586880444',
|
|
email: 'luisenriquesalgadozavaleta@gmail.com',
|
|
curp: 'SAZL990504HDFLVS06',
|
|
rfc: 'SAZL990504KY0',
|
|
proyecto: 'SOLANA',
|
|
unidadCodigo: '9',
|
|
payloadJson: '{"datosGenerales":{"estadoCivil":"SOLTERO"}}',
|
|
}),
|
|
])
|
|
|
|
const lista = (await listarContactosLocal()).contactos
|
|
|
|
expect(lista).toHaveLength(1)
|
|
expect(lista[0]).toMatchObject({
|
|
id: 'completo',
|
|
nombre: 'Luis Enrique Salgado Zavaleta',
|
|
telefono: '+52 5586880444',
|
|
email: 'luisenriquesalgadozavaleta@gmail.com',
|
|
estado: 'Cliente',
|
|
})
|
|
})
|
|
|
|
it('fusiona el registro hueco aunque llegue después de la ficha completa', async () => {
|
|
prismaMock.cliente.findMany.mockResolvedValue([
|
|
clienteFake({
|
|
id: 'completo',
|
|
nombreCompleto: 'GRACIELA BAUTISTA VELASCO',
|
|
celular: '+52 6641159092',
|
|
email: 'gbautista1304@gmail.com',
|
|
}),
|
|
clienteFake({ id: 'hueco', nombreCompleto: 'Graciela Bautista Velasco', payloadJson: '{}' }),
|
|
])
|
|
|
|
const lista = (await listarContactosLocal()).contactos
|
|
expect(lista).toHaveLength(1)
|
|
expect(lista[0]?.id).toBe('completo')
|
|
})
|
|
|
|
it('no fusiona a dos personas distintas con el mismo nombre si tienen teléfonos distintos', async () => {
|
|
prismaMock.cliente.findMany.mockResolvedValue([
|
|
clienteFake({ id: 'c1', nombreCompleto: 'JUAN PÉREZ', celular: '4771234567' }),
|
|
clienteFake({ id: 'c2', nombreCompleto: 'JUAN PÉREZ', celular: '6649998877' }),
|
|
])
|
|
|
|
const lista = (await listarContactosLocal()).contactos
|
|
expect(lista.map((c) => c.id).sort()).toEqual(['c1', 'c2'])
|
|
})
|
|
|
|
it('un Cliente hueco se fusiona con la captura del mismo nombre (gana la que trae más datos)', async () => {
|
|
prismaMock.cliente.findMany.mockResolvedValue([
|
|
clienteFake({
|
|
id: 'hueco',
|
|
nombreCompleto: 'Guadalupe',
|
|
curp: '',
|
|
rfc: '',
|
|
payloadJson: '{}',
|
|
createdAt: new Date('2026-09-15T10:00:00'),
|
|
}),
|
|
])
|
|
prismaMock.leadCaptura.findMany.mockResolvedValue([
|
|
capturaFake({
|
|
leadId: 'loc_g',
|
|
nombreLead: 'Guadalupe',
|
|
telefono: '+52 664 222 6090',
|
|
email: 'lupisintj1@hotmail.com',
|
|
etapa: 'Contactado',
|
|
}),
|
|
])
|
|
|
|
const lista = (await listarContactosLocal()).contactos
|
|
|
|
expect(lista).toHaveLength(1)
|
|
expect(lista[0]).toMatchObject({
|
|
id: 'loc_g',
|
|
telefono: '+52 664 222 6090',
|
|
email: 'lupisintj1@hotmail.com',
|
|
estado: 'Contactado',
|
|
})
|
|
})
|
|
|
|
it('pagina de 100 en 100 con hayMas (la página 2 trae el siguiente bloque)', async () => {
|
|
// 101 clientes: la página 1 llena 100 y detecta que hay más
|
|
prismaMock.cliente.findMany.mockResolvedValue(
|
|
Array.from({ length: 101 }, (_, i) =>
|
|
clienteFake({ id: `c${i + 1}`, celular: `4770000${String(i).padStart(3, '0')}`, createdAt: new Date(2026, 8, 1, 0, 0, 0, i * 1000) }),
|
|
),
|
|
)
|
|
|
|
const pagina1 = await listarContactosLocal(undefined, 1)
|
|
expect(pagina1.pagina).toBe(1)
|
|
expect(pagina1.porPagina).toBe(100)
|
|
expect(pagina1.contactos).toHaveLength(100)
|
|
expect(pagina1.hayMas).toBe(true)
|
|
|
|
// La página 2 recibe el siguiente bloque (skip=100, take=101)
|
|
prismaMock.cliente.findMany.mockResolvedValue([
|
|
clienteFake({ id: 'c101', celular: '4770000100' }),
|
|
])
|
|
const pagina2 = await listarContactosLocal(undefined, 2)
|
|
expect(pagina2.pagina).toBe(2)
|
|
expect(pagina2.contactos).toHaveLength(1)
|
|
expect(pagina2.hayMas).toBe(false)
|
|
})
|
|
})
|
|
|
|
describe('detalleContactoLocal', () => {
|
|
it('null si el id no existe en ninguna tabla local', async () => {
|
|
expect(await detalleContactoLocal('nope')).toBeNull()
|
|
})
|
|
|
|
it('por cliente.id: contacto + propiedad + relaciones + historial derivado de lo local', async () => {
|
|
const cliente = clienteFake({
|
|
id: 'c1',
|
|
nombreCompleto: 'JUAN PÉREZ',
|
|
celular: '4771234567',
|
|
email: 'juan@correo.mx',
|
|
proyecto: 'SENDA',
|
|
unidadCodigo: 'SENDA-101',
|
|
mondayApartadoId: 'loc_a1',
|
|
capturadoPorId: 'u-1',
|
|
createdAt: new Date('2026-09-01T10:00:00'),
|
|
})
|
|
prismaMock.cliente.findFirst.mockResolvedValue(cliente)
|
|
prismaMock.leadCaptura.findMany.mockResolvedValue([
|
|
capturaFake({ leadId: 'loc_a1', board: 'APARTADO', etapa: 'Pago Apartado', telefono: '4771234567' }),
|
|
capturaFake({ leadId: 'loc_o1', board: 'OPORTUNIDADES', etapa: 'Aparto', telefono: '4771234567', desarrollo: 'SENDA', modelo: '1R' }),
|
|
capturaFake({ leadId: 'loc_x', board: 'LEADS', etapa: 'NUEVO', telefono: '9990001111' }), // otro teléfono: fuera
|
|
])
|
|
prismaMock.cotizacion.findMany.mockResolvedValue([
|
|
{
|
|
id: 'cot1',
|
|
unidadCodigo: 'SENDA-101',
|
|
tipoPropuesta: 'BANCARIO',
|
|
precioFinal: 4_400_000,
|
|
vendedorId: 'u-1',
|
|
createdAt: new Date('2026-08-30T10:00:00'),
|
|
},
|
|
])
|
|
prismaMock.documento.findMany.mockResolvedValue([
|
|
{ id: 'd1', tipo: 'INE', createdAt: new Date('2026-09-01T12:00:00') },
|
|
])
|
|
|
|
const detalle = await detalleContactoLocal('c1')
|
|
expect(detalle).not.toBeNull()
|
|
if (detalle === null) return
|
|
|
|
expect(detalle.contacto).toMatchObject({
|
|
nombre: 'JUAN PÉREZ',
|
|
telefono: '4771234567',
|
|
email: 'juan@correo.mx',
|
|
estado: 'Cliente',
|
|
curp: 'CURP123',
|
|
rfc: 'RFC123',
|
|
})
|
|
expect(detalle.propiedad).toMatchObject({
|
|
id: 'loc_a1',
|
|
unidadCodigo: 'SENDA-101',
|
|
desarrollo: 'SENDA',
|
|
estado: 'Pago Apartado',
|
|
precioFinal: 4_400_000,
|
|
atendidoPor: 'Martin Zavala',
|
|
})
|
|
expect(detalle.relaciones.oportunidades).toHaveLength(1)
|
|
expect(detalle.relaciones.oportunidades[0]).toMatchObject({
|
|
id: 'loc_o1',
|
|
estado: 'Aparto',
|
|
atendidoPor: 'Martin Zavala',
|
|
detalle: 'SENDA · 1R',
|
|
})
|
|
expect(detalle.relaciones.apartados[0]).toMatchObject({ id: 'loc_a1', detalle: 'SENDA-101' })
|
|
expect(detalle.relaciones.leads).toHaveLength(0) // el de otro teléfono no entra
|
|
|
|
const detalles = detalle.historial.map((h) => h.detalle)
|
|
expect(detalles).toContain('Alta de cliente registrada (SENDA-101)')
|
|
expect(detalles).toContain('Documento subido (INE)')
|
|
expect(detalles).toContain('Cotización SENDA-101 (BANCARIO)')
|
|
expect(detalles.some((d) => d.startsWith('Captura en la app'))).toBe(true)
|
|
})
|
|
|
|
it('por leadId (loc_*): contacto desde la captura, sin propiedad', async () => {
|
|
prismaMock.leadCaptura.findUnique.mockResolvedValue(
|
|
capturaFake({ leadId: 'loc_1', nombreLead: 'ANA DEMO', telefono: '6649998877', etapa: 'Afluencia' }),
|
|
)
|
|
prismaMock.leadCaptura.findMany.mockResolvedValue([
|
|
capturaFake({ leadId: 'loc_1', nombreLead: 'ANA DEMO', telefono: '6649998877' }),
|
|
])
|
|
|
|
const detalle = await detalleContactoLocal('loc_1')
|
|
expect(detalle).not.toBeNull()
|
|
if (detalle === null) return
|
|
expect(detalle.contacto).toMatchObject({ nombre: 'ANA DEMO', telefono: '6649998877', estado: 'Afluencia' })
|
|
expect(detalle.propiedad).toBeNull()
|
|
expect(detalle.relaciones.oportunidades).toHaveLength(1)
|
|
expect(detalle.historial.length).toBeGreaterThan(0)
|
|
})
|
|
|
|
it('completa el perfil con el payloadJson del alta (estado civil, nacimiento, actividad, dirección)', async () => {
|
|
prismaMock.cliente.findFirst.mockResolvedValue(
|
|
clienteFake({
|
|
id: 'c1',
|
|
nombreCompleto: 'LUIS ENRIQUE SALGADO ZAVALETA',
|
|
celular: '5586880444',
|
|
email: 'luis@correo.mx',
|
|
curp: '',
|
|
rfc: '',
|
|
payloadJson: JSON.stringify({
|
|
datosGenerales: {
|
|
estadoCivil: 'SOLTERO',
|
|
fechaNacimiento: '1999-05-04',
|
|
actividadOcupacion: 'PILOTO AVIADOR',
|
|
direccion: 'C.SAN FELIPE EJIDO FRANCISCO VILLA',
|
|
},
|
|
empleo: { compania: 'FRASA', direccion: 'AV COLINA DE SAN PABLO' },
|
|
// El co-acreditado repite los campos vacíos: no debe pisar los reales
|
|
coacreditado: { tieneCoacreditado: false, generales: { estadoCivil: '', fechaNacimiento: '', actividadOcupacion: '', direccion: '' } },
|
|
}),
|
|
}),
|
|
)
|
|
|
|
const detalle = await detalleContactoLocal('c1')
|
|
expect(detalle?.contacto).toMatchObject({
|
|
estadoCivil: 'SOLTERO',
|
|
fechaNacimiento: '1999-05-04',
|
|
actividadEconomica: 'PILOTO AVIADOR',
|
|
direccion: 'C.SAN FELIPE EJIDO FRANCISCO VILLA',
|
|
})
|
|
})
|
|
|
|
it('toma el perfilamiento del datosJson de la captura cuando no hay Cliente', async () => {
|
|
const captura = capturaFake({
|
|
leadId: 'loc_1',
|
|
nombreLead: 'RAMON MORALES',
|
|
telefono: '6643535353',
|
|
email: 'ramon.morales@gmail.com',
|
|
datosJson: JSON.stringify({
|
|
edad: 41,
|
|
estadoCivil: 'Casado(a)',
|
|
ocupacion: 'empleado',
|
|
rangoSalarial: '50000',
|
|
}),
|
|
})
|
|
prismaMock.leadCaptura.findUnique.mockResolvedValue(captura)
|
|
prismaMock.leadCaptura.findMany.mockResolvedValue([captura])
|
|
|
|
const detalle = await detalleContactoLocal('loc_1')
|
|
expect(detalle?.contacto).toMatchObject({
|
|
nombre: 'RAMON MORALES',
|
|
estadoCivil: 'Casado(a)',
|
|
actividadEconomica: 'empleado',
|
|
})
|
|
// No se inventa fecha de nacimiento a partir de la edad
|
|
expect(detalle?.contacto['fechaNacimiento']).toBe('')
|
|
expect(detalle?.contacto['direccion']).toBe('')
|
|
})
|
|
|
|
it('incluye los documentos del registro hueco de la misma persona (no se pierden al fusionar)', async () => {
|
|
prismaMock.cliente.findFirst.mockResolvedValue(
|
|
clienteFake({
|
|
id: 'c1',
|
|
nombreCompleto: 'DEYSI LORENA ALEMAN FIGUEROA',
|
|
celular: '6643998451',
|
|
email: 'daleman@frasa.com.mx',
|
|
}),
|
|
)
|
|
prismaMock.cliente.findMany.mockResolvedValue([
|
|
{ id: 'hueco', nombreCompleto: 'DEYSI LORENA ALEMAN FIGUEROA', celular: null, email: null },
|
|
{ id: 'otro', nombreCompleto: 'OTRA PERSONA', celular: null, email: null },
|
|
])
|
|
prismaMock.documento.findMany.mockResolvedValue([
|
|
{ id: 'd1', tipo: 'INE', createdAt: new Date('2026-09-01T12:00:00') },
|
|
])
|
|
|
|
const detalle = await detalleContactoLocal('c1')
|
|
|
|
expect(prismaMock.documento.findMany).toHaveBeenCalledWith(
|
|
expect.objectContaining({ where: { clienteId: { in: ['c1', 'hueco'] } } }),
|
|
)
|
|
expect(detalle?.historial.some((h) => h.detalle === 'Documento subido (INE)')).toBe(true)
|
|
})
|
|
|
|
it('si la ficha visible es la captura, también se muestran los documentos de su Cliente hueco', async () => {
|
|
prismaMock.leadCaptura.findUnique.mockResolvedValue(
|
|
capturaFake({ leadId: 'loc_g', nombreLead: 'Guadalupe', telefono: '6642226090', etapa: 'Contactado' }),
|
|
)
|
|
prismaMock.leadCaptura.findMany.mockResolvedValue([
|
|
capturaFake({ leadId: 'loc_g', nombreLead: 'Guadalupe', telefono: '6642226090', etapa: 'Contactado' }),
|
|
])
|
|
prismaMock.cliente.findMany.mockResolvedValue([
|
|
{ id: 'hueco', nombreCompleto: 'Guadalupe', celular: null, email: null },
|
|
])
|
|
prismaMock.documento.findMany.mockResolvedValue([
|
|
{ id: 'd1', tipo: 'INE', createdAt: new Date('2026-09-01T12:00:00') },
|
|
])
|
|
|
|
const detalle = await detalleContactoLocal('loc_g')
|
|
|
|
expect(prismaMock.documento.findMany).toHaveBeenCalledWith(
|
|
expect.objectContaining({ where: { clienteId: { in: ['hueco'] } } }),
|
|
)
|
|
expect(detalle?.historial.some((h) => h.detalle === 'Documento subido (INE)')).toBe(true)
|
|
})
|
|
})
|