@coldiq/mcp 0.1.0

package/tests/registry-find-people.test.ts

@@ -0,0 +1,467 @@
+import { describe, it, expect } from 'vitest'
+import { getProviders } from '../src/registry.js'
+
+const providers = () => getProviders('find_people')
+const get = (id: string) => {
+  const p = providers().find((p) => p.id === id)
+  if (!p) throw new Error(`Provider '${id}' not found in find_people`)
+  return p
+}
+
+// ---------------------------------------------------------------------------
+// sumble-people-find
+// ---------------------------------------------------------------------------
+
+describe('sumble-people-find', () => {
+  const p = () => get('sumble-people-find')
+
+  it('isApplicable: true with company_domains + job_titles', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'], job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: true with company_linkedin_urls + seniorities', () => {
+    expect(p().isApplicable!({ company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'], seniorities: ['C-Level'] })).toBe(true)
+  })
+
+  it('isApplicable: false without company identifier', () => {
+    expect(p().isApplicable!({ job_titles: ['CEO'] })).toBe(false)
+  })
+
+  it('isApplicable: false without job_titles or seniorities', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'] })).toBe(false)
+  })
+
+  it('mapParams uses domain when company_domains present', () => {
+    const result = p().mapParams({ company_domains: ['coldiq.com'], job_titles: ['CEO'], limit: 5 })
+    expect(result).toEqual({
+      body: {
+        organization: { domain: 'coldiq.com' },
+        filters: {
+          job_functions: ['CEO'],
+          job_levels: undefined,
+          countries: undefined,
+          query: undefined,
+        },
+        limit: 5,
+      },
+    })
+  })
+
+  it('mapParams falls back to linkedin_url when no domain', () => {
+    const result = p().mapParams({
+      company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'],
+      seniorities: ['Director'],
+    })
+    const body = result.body as Record<string, unknown>
+    expect((body.organization as Record<string, unknown>).linkedin_url).toBe('https://www.linkedin.com/company/coldiq')
+  })
+
+  it('mapParams joins keywords into query string', () => {
+    const result = p().mapParams({
+      company_domains: ['coldiq.com'],
+      job_titles: ['CEO'],
+      keywords: ['sales', 'outbound'],
+    })
+    const body = result.body as Record<string, unknown>
+    expect((body.filters as Record<string, unknown>).query).toBe('sales outbound')
+  })
+
+  it('hasResult: true when people array non-empty', () => {
+    expect(p().hasResult({ people: [{ name: 'Michel Lieben' }] })).toBe(true)
+  })
+
+  it('hasResult: false when people is empty', () => {
+    expect(p().hasResult({ people: [] })).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+
+  it('priority is 6', () => {
+    expect(p().priority).toBe(6)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// prospeo-search-person
+// ---------------------------------------------------------------------------
+
+describe('prospeo-search-person', () => {
+  const p = () => get('prospeo-search-person')
+
+  it('isApplicable: true with job_titles', () => {
+    expect(p().isApplicable!({ job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: true with company_domains', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'] })).toBe(true)
+  })
+
+  it('isApplicable: false with only keywords (Prospeo does not support keyword search)', () => {
+    expect(p().isApplicable!({ keywords: ['outbound sales'] })).toBe(false)
+  })
+
+  it('isApplicable: false with only locations', () => {
+    expect(p().isApplicable!({ locations: ['Belgium'] })).toBe(false)
+  })
+
+  it('mapParams builds Prospeo filter shape', () => {
+    expect(p().mapParams({
+      job_titles: ['CEO', 'CTO'],
+      seniorities: ['C-Level'],
+      company_domains: ['coldiq.com'],
+      locations: ['Belgium'],
+    })).toEqual({
+      body: {
+        filters: {
+          job_title: { include: ['CEO', 'CTO'] },
+          person_seniority: { include: ['C-Level'] },
+          company: { websites: { include: ['coldiq.com'] } },
+          person_location: { include: ['Belgium'] },
+        },
+      },
+    })
+  })
+
+  it('mapParams omits absent filter keys', () => {
+    const result = p().mapParams({ job_titles: ['CEO'] })
+    const filters = (result.body as Record<string, unknown>).filters as Record<string, unknown>
+    expect(filters.person_seniority).toBeUndefined()
+    expect(filters.company).toBeUndefined()
+    expect(filters.person_location).toBeUndefined()
+  })
+
+  it('hasResult: true when data array non-empty', () => {
+    expect(p().hasResult({ data: [{ name: 'Michel Lieben' }] })).toBe(true)
+  })
+
+  it('hasResult: false when data is empty', () => {
+    expect(p().hasResult({ data: [] })).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+
+  it('priority is 7', () => {
+    expect(p().priority).toBe(7)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ai-ark-people
+// ---------------------------------------------------------------------------
+
+describe('ai-ark-people', () => {
+  const p = () => get('ai-ark-people')
+
+  it('isApplicable: true with job_titles', () => {
+    expect(p().isApplicable!({ job_titles: ['VP Sales'] })).toBe(true)
+  })
+
+  it('isApplicable: true with seniorities', () => {
+    expect(p().isApplicable!({ seniorities: ['Director'] })).toBe(true)
+  })
+
+  it('isApplicable: true with keywords', () => {
+    expect(p().isApplicable!({ keywords: ['cold email'] })).toBe(true)
+  })
+
+  it('isApplicable: false with only company_domains', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'] })).toBe(false)
+  })
+
+  it('mapParams builds AI-Ark contact shape', () => {
+    expect(p().mapParams({
+      job_titles: ['VP Sales'],
+      seniorities: ['Director'],
+      locations: ['Belgium'],
+      keywords: ['outbound'],
+      limit: 20,
+    })).toEqual({
+      body: {
+        contact: {
+          departmentAndFunction: { any: { include: ['VP Sales'] } },
+          seniority: { any: { include: ['Director'] } },
+          location: { any: { include: ['Belgium'] } },
+          keywordsInProfile: { any: { include: ['outbound'] } },
+        },
+        size: 20,
+      },
+    })
+  })
+
+  it('mapParams omits absent contact keys', () => {
+    const result = p().mapParams({ job_titles: ['CEO'] })
+    const contact = (result.body as Record<string, unknown>).contact as Record<string, unknown>
+    expect(contact.seniority).toBeUndefined()
+    expect(contact.location).toBeUndefined()
+    expect(contact.keywordsInProfile).toBeUndefined()
+  })
+
+  it('mapParams caps size at 100', () => {
+    const result = p().mapParams({ job_titles: ['CEO'], limit: 999 })
+    expect((result.body as Record<string, unknown>).size).toBe(100)
+  })
+
+  it('hasResult: true when content array non-empty', () => {
+    expect(p().hasResult({ content: [{ name: 'Michel Lieben' }] })).toBe(true)
+  })
+
+  it('hasResult: false when content is empty', () => {
+    expect(p().hasResult({ content: [] })).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+
+  it('priority is 8', () => {
+    expect(p().priority).toBe(8)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// fullenrich-people-search
+// ---------------------------------------------------------------------------
+
+describe('fullenrich-people-search', () => {
+  const p = () => get('fullenrich-people-search')
+
+  it('has no isApplicable gate (always runs)', () => {
+    expect(p().isApplicable).toBeUndefined()
+  })
+
+  it('mapParams wraps all fields in {value} objects', () => {
+    expect(p().mapParams({
+      company_domains: ['coldiq.com'],
+      job_titles: ['CEO'],
+      seniorities: ['C-Level'],
+      locations: ['Belgium'],
+      limit: 10,
+    })).toEqual({
+      body: {
+        current_company_domains: [{ value: 'coldiq.com' }],
+        current_position_titles: [{ value: 'CEO' }],
+        current_position_seniority_level: [{ value: 'C-Level' }],
+        person_locations: [{ value: 'Belgium' }],
+        limit: 10,
+      },
+    })
+  })
+
+  it('mapParams omits undefined fields', () => {
+    const result = p().mapParams({ job_titles: ['CEO'], limit: 5 })
+    const body = result.body as Record<string, unknown>
+    expect(body.current_company_domains).toBeUndefined()
+    expect(body.current_position_seniority_level).toBeUndefined()
+    expect(body.person_locations).toBeUndefined()
+  })
+
+  it('mapParams caps limit at 100', () => {
+    const result = p().mapParams({ limit: 500 })
+    expect((result.body as Record<string, unknown>).limit).toBe(100)
+  })
+
+  it('hasResult: true when people array non-empty', () => {
+    expect(p().hasResult({ people: [{ name: 'Michel Lieben' }] })).toBe(true)
+  })
+
+  it('hasResult: false when people is empty', () => {
+    expect(p().hasResult({ people: [] })).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+
+  it('priority is 9', () => {
+    expect(p().priority).toBe(9)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// findymail-search-employees
+// ---------------------------------------------------------------------------
+
+describe('findymail-search-employees', () => {
+  const p = () => get('findymail-search-employees')
+
+  it('isApplicable: true with company_domains + job_titles', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'], job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: false without company_domains', () => {
+    expect(p().isApplicable!({ job_titles: ['CEO'] })).toBe(false)
+  })
+
+  it('isApplicable: false without job_titles', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'] })).toBe(false)
+  })
+
+  it('mapParams uses first domain and caps count at 5', () => {
+    expect(p().mapParams({
+      company_domains: ['coldiq.com', 'microsoft.com'],
+      job_titles: ['CEO', 'CTO'],
+      limit: 3,
+    })).toEqual({
+      body: {
+        website: 'coldiq.com',
+        job_titles: ['CEO', 'CTO'],
+        count: 3,
+      },
+    })
+  })
+
+  it('mapParams hard-caps count at 5 even when limit > 5', () => {
+    const result = p().mapParams({ company_domains: ['coldiq.com'], job_titles: ['CEO'], limit: 100 })
+    expect((result.body as Record<string, unknown>).count).toBe(5)
+  })
+
+  it('hasResult: true when contacts key present', () => {
+    expect(p().hasResult({ contacts: [{ email: 'michel@coldiq.com' }] })).toBe(true)
+  })
+
+  it('hasResult: true when results key present', () => {
+    expect(p().hasResult({ results: [{ name: 'Michel Lieben' }] })).toBe(true)
+  })
+
+  it('hasResult: true when data is a non-empty array', () => {
+    expect(p().hasResult([{ email: 'michel@coldiq.com' }])).toBe(true)
+  })
+
+  it('hasResult: false when data is empty array', () => {
+    expect(p().hasResult([])).toBe(false)
+  })
+
+  it('hasResult: false on empty object', () => {
+    expect(p().hasResult({})).toBe(false)
+  })
+
+  it('priority is 10', () => {
+    expect(p().priority).toBe(10)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// apollo — keywords array is joined into a single string for q_keywords
+// ---------------------------------------------------------------------------
+
+describe('apollo (find_people)', () => {
+  const p = () => get('apollo')
+
+  it('mapParams joins keywords array into space-separated string', () => {
+    const result = p().mapParams({ keywords: ['growth', 'AI'], job_titles: ['CEO'], limit: 10 })
+    const body = result.body as Record<string, unknown>
+    expect(body.q_keywords).toBe('growth AI')
+  })
+
+  it('mapParams omits q_keywords when keywords absent', () => {
+    const result = p().mapParams({ job_titles: ['CEO'], limit: 10 })
+    const body = result.body as Record<string, unknown>
+    expect(body.q_keywords).toBeUndefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// linkupapi-search-profiles — keywords array is joined for keyword field
+// ---------------------------------------------------------------------------
+
+describe('linkupapi-search-profiles (find_people)', () => {
+  const p = () => get('linkupapi-search-profiles')
+
+  it('mapParams joins keywords array into space-separated string', () => {
+    const result = p().mapParams({ keywords: ['sales', 'B2B'], job_titles: ['AE'], limit: 10 })
+    const body = result.body as Record<string, unknown>
+    expect(body.keyword).toBe('sales B2B')
+  })
+
+  it('mapParams omits keyword when keywords absent', () => {
+    const result = p().mapParams({ job_titles: ['CEO'], limit: 5 })
+    const body = result.body as Record<string, unknown>
+    expect(body.keyword).toBeUndefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// LeadsFactory
+// ---------------------------------------------------------------------------
+
+describe('leadsfactory (find_people)', () => {
+  const p = () => get('leadsfactory')
+  const personas = (result: ReturnType<ReturnType<typeof p>['mapParams']>) =>
+    ((result.body as Record<string, unknown>).search as Record<string, unknown>).personas as { job_title: string }[]
+
+  it('same-domain variants collapse to 1 persona with comma-joined titles', () => {
+    const result = p().mapParams({ company_domains: ['coldiq.com'], job_titles: ['VP Sales', 'Head of Sales'], limit: 5 })
+    expect(personas(result)).toEqual([{ job_title: 'VP Sales, Head of Sales' }])
+  })
+
+  it('"of" variant is deduped before domain grouping — VP Sales + VP of Sales + Head of Sales → 1 persona', () => {
+    const result = p().mapParams({
+      company_domains: ['coldiq.com'],
+      job_titles: ['VP Sales', 'VP of Sales', 'Head of Sales'],
+      limit: 5,
+    })
+    expect(personas(result)).toEqual([{ job_title: 'VP Sales, Head of Sales' }])
+  })
+
+  it('different-domain roles stay as separate personas', () => {
+    const result = p().mapParams({ company_domains: ['coldiq.com'], job_titles: ['CEO', 'VP of Sales'], limit: 5 })
+    expect(personas(result)).toEqual([{ job_title: 'CEO' }, { job_title: 'VP of Sales' }])
+  })
+
+  it('C-suite abbreviations are treated as distinct roles', () => {
+    const result = p().mapParams({ company_domains: ['coldiq.com'], job_titles: ['CEO', 'CRO'], limit: 5 })
+    expect(personas(result)).toEqual([{ job_title: 'CEO' }, { job_title: 'CRO' }])
+  })
+
+  it('case-insensitive "of" duplicates are deduped, first casing is kept', () => {
+    const result = p().mapParams({ company_domains: ['coldiq.com'], job_titles: ['VP Sales', 'vp sales'], limit: 3 })
+    expect(personas(result)).toEqual([{ job_title: 'VP Sales' }])
+  })
+
+  it('no job_titles → Decision Maker fallback', () => {
+    const result = p().mapParams({ company_domains: ['coldiq.com'], limit: 3 })
+    expect((result.body as Record<string, unknown>).search).toEqual({
+      max_persona_results: 3,
+      personas: [{ job_title: 'Decision Maker' }],
+    })
+  })
+
+  it('seniorities and keywords are not forwarded', () => {
+    const result = p().mapParams({
+      company_domains: ['coldiq.com'],
+      job_titles: ['CEO'],
+      seniorities: ['C-suite'],
+      keywords: ['AI'],
+      limit: 5,
+    })
+    const body = result.body as Record<string, unknown>
+    expect(body.seniorities).toBeUndefined()
+    expect(body.keywords).toBeUndefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Ordering: find_people providers sorted correctly
+// ---------------------------------------------------------------------------
+
+describe('find_people priority ordering', () => {
+  it('all providers are sorted by priority', () => {
+    const ps = providers()
+    for (let i = 1; i < ps.length; i++) {
+      expect(ps[i].priority).toBeGreaterThanOrEqual(ps[i - 1].priority)
+    }
+  })
+
+  it('leadsfactory is first (priority 1)', () => {
+    expect(providers()[0].id).toBe('leadsfactory')
+  })
+
+  it('findymail-search-employees is last in the wired set (priority 10)', () => {
+    const ps = providers()
+    expect(ps[ps.length - 1].id).toBe('findymail-search-employees')
+  })
+})