491 lines
18 KiB
TypeScript
491 lines
18 KiB
TypeScript
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
|
|
import { HubSpotConnector } from '../../src/connectors/hubspot-connector.js';
|
|
import { SalesforceConnector } from '../../src/connectors/salesforce-connector.js';
|
|
import { PipedriveConnector } from '../../src/connectors/pipedrive-connector.js';
|
|
import { AirtableConnector } from '../../src/connectors/airtable-connector.js';
|
|
import { GitLabConnector } from '../../src/connectors/gitlab-connector.js';
|
|
import { BitbucketConnector } from '../../src/connectors/bitbucket-connector.js';
|
|
import { DropboxConnector } from '../../src/connectors/dropbox-connector.js';
|
|
import { PostgresConnector } from '../../src/connectors/postgres-connector.js';
|
|
import type { VaultStore } from '@waggle/core';
|
|
|
|
function createMockVault(connectorId: string, cred?: { value: string; isExpired: boolean }, extras?: Record<string, string>): VaultStore {
|
|
return {
|
|
getConnectorCredential: vi.fn((id: string) => {
|
|
if (id === connectorId && cred) return { ...cred, type: 'bearer' };
|
|
return null;
|
|
}),
|
|
get: vi.fn((key: string) => {
|
|
if (extras && extras[key]) return { value: extras[key] };
|
|
return null;
|
|
}),
|
|
set: vi.fn(),
|
|
delete: vi.fn(),
|
|
list: vi.fn(() => []),
|
|
has: vi.fn(() => false),
|
|
setConnectorCredential: vi.fn(),
|
|
migrateFromConfig: vi.fn(() => 0),
|
|
} as unknown as VaultStore;
|
|
}
|
|
|
|
// ── CRM Connectors ──────────────────────────────────────────
|
|
|
|
describe('HubSpotConnector', () => {
|
|
let connector: HubSpotConnector;
|
|
let originalFetch: typeof globalThis.fetch;
|
|
|
|
beforeEach(() => {
|
|
connector = new HubSpotConnector();
|
|
originalFetch = globalThis.fetch;
|
|
});
|
|
|
|
afterEach(() => {
|
|
globalThis.fetch = originalFetch;
|
|
});
|
|
|
|
it('has correct identity', () => {
|
|
expect(connector.id).toBe('hubspot');
|
|
expect(connector.name).toBe('HubSpot');
|
|
expect(connector.service).toBe('hubspot.com');
|
|
expect(connector.authType).toBe('bearer');
|
|
expect(connector.actions).toHaveLength(7);
|
|
});
|
|
|
|
it('actions include expected names', () => {
|
|
const names = connector.actions.map(a => a.name);
|
|
expect(names).toContain('list_contacts');
|
|
expect(names).toContain('get_contact');
|
|
expect(names).toContain('create_contact');
|
|
expect(names).toContain('search_contacts');
|
|
expect(names).toContain('list_deals');
|
|
expect(names).toContain('create_deal');
|
|
expect(names).toContain('list_companies');
|
|
});
|
|
|
|
it('execute returns error when not connected', async () => {
|
|
const result = await connector.execute('list_contacts', {});
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain('Not connected');
|
|
});
|
|
|
|
it('toDefinition maps tools correctly', () => {
|
|
const def = connector.toDefinition('connected');
|
|
expect(def.tools).toContain('connector_hubspot_list_contacts');
|
|
expect(def.tools).toContain('connector_hubspot_create_deal');
|
|
expect(def.tools).toHaveLength(7);
|
|
});
|
|
|
|
it('execute(list_contacts) returns data when connected', async () => {
|
|
const vault = createMockVault('hubspot', { value: 'test-token', isExpired: false });
|
|
await connector.connect(vault);
|
|
|
|
const mockData = { results: [{ id: '1', properties: { email: 'test@example.com' } }] };
|
|
globalThis.fetch = vi.fn().mockResolvedValue({ ok: true, json: async () => mockData }) as unknown as typeof fetch;
|
|
|
|
const result = await connector.execute('list_contacts', { limit: 5 });
|
|
expect(result.success).toBe(true);
|
|
expect(result.data).toEqual(mockData);
|
|
});
|
|
});
|
|
|
|
describe('SalesforceConnector', () => {
|
|
let connector: SalesforceConnector;
|
|
let originalFetch: typeof globalThis.fetch;
|
|
|
|
beforeEach(() => {
|
|
connector = new SalesforceConnector();
|
|
originalFetch = globalThis.fetch;
|
|
});
|
|
|
|
afterEach(() => {
|
|
globalThis.fetch = originalFetch;
|
|
});
|
|
|
|
it('has correct identity', () => {
|
|
expect(connector.id).toBe('salesforce');
|
|
expect(connector.name).toBe('Salesforce');
|
|
expect(connector.service).toBe('salesforce.com');
|
|
expect(connector.authType).toBe('bearer');
|
|
expect(connector.actions).toHaveLength(6);
|
|
});
|
|
|
|
it('actions include expected names', () => {
|
|
const names = connector.actions.map(a => a.name);
|
|
expect(names).toContain('search');
|
|
expect(names).toContain('list_contacts');
|
|
expect(names).toContain('get_record');
|
|
expect(names).toContain('create_record');
|
|
expect(names).toContain('update_record');
|
|
expect(names).toContain('list_opportunities');
|
|
});
|
|
|
|
it('execute returns error when not connected (no token)', async () => {
|
|
const result = await connector.execute('search', { query: 'SELECT Id FROM Account' });
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain('Not connected');
|
|
});
|
|
|
|
it('execute returns error when no instance URL', async () => {
|
|
const vault = createMockVault('salesforce', { value: 'token123', isExpired: false });
|
|
await connector.connect(vault);
|
|
// Token is set but no instance_url
|
|
const result = await connector.execute('search', { query: 'SELECT Id FROM Account' });
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain('Not connected');
|
|
});
|
|
|
|
it('toDefinition maps tools correctly', () => {
|
|
const def = connector.toDefinition('connected');
|
|
expect(def.tools).toContain('connector_salesforce_search');
|
|
expect(def.tools).toContain('connector_salesforce_create_record');
|
|
expect(def.tools).toHaveLength(6);
|
|
});
|
|
|
|
it('execute(search) works with instance URL', async () => {
|
|
const vault = createMockVault('salesforce', { value: 'token123', isExpired: false }, {
|
|
'connector:salesforce:instance_url': 'https://myco.salesforce.com',
|
|
});
|
|
await connector.connect(vault);
|
|
|
|
const mockData = { records: [{ Id: '001xx', Name: 'Test Account' }], totalSize: 1 };
|
|
globalThis.fetch = vi.fn().mockResolvedValue({ ok: true, json: async () => mockData }) as unknown as typeof fetch;
|
|
|
|
const result = await connector.execute('search', { query: 'SELECT Id, Name FROM Account LIMIT 1' });
|
|
expect(result.success).toBe(true);
|
|
expect(result.data).toEqual(mockData);
|
|
});
|
|
});
|
|
|
|
describe('PipedriveConnector', () => {
|
|
let connector: PipedriveConnector;
|
|
let originalFetch: typeof globalThis.fetch;
|
|
|
|
beforeEach(() => {
|
|
connector = new PipedriveConnector();
|
|
originalFetch = globalThis.fetch;
|
|
});
|
|
|
|
afterEach(() => {
|
|
globalThis.fetch = originalFetch;
|
|
});
|
|
|
|
it('has correct identity', () => {
|
|
expect(connector.id).toBe('pipedrive');
|
|
expect(connector.name).toBe('Pipedrive');
|
|
expect(connector.service).toBe('pipedrive.com');
|
|
expect(connector.authType).toBe('api_key');
|
|
expect(connector.actions).toHaveLength(7);
|
|
});
|
|
|
|
it('actions include expected names', () => {
|
|
const names = connector.actions.map(a => a.name);
|
|
expect(names).toContain('list_deals');
|
|
expect(names).toContain('get_deal');
|
|
expect(names).toContain('create_deal');
|
|
expect(names).toContain('search_deals');
|
|
expect(names).toContain('list_persons');
|
|
expect(names).toContain('create_person');
|
|
expect(names).toContain('list_activities');
|
|
});
|
|
|
|
it('execute returns error when not connected', async () => {
|
|
const result = await connector.execute('list_deals', {});
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain('Not connected');
|
|
});
|
|
|
|
it('toDefinition maps tools correctly', () => {
|
|
const def = connector.toDefinition('connected');
|
|
expect(def.tools).toContain('connector_pipedrive_list_deals');
|
|
expect(def.tools).toContain('connector_pipedrive_create_person');
|
|
expect(def.tools).toHaveLength(7);
|
|
});
|
|
|
|
it('execute(list_deals) returns data when connected', async () => {
|
|
const vault = createMockVault('pipedrive', { value: 'api-key-123', isExpired: false });
|
|
await connector.connect(vault);
|
|
|
|
const mockData = { success: true, data: [{ id: 1, title: 'Big Deal' }] };
|
|
globalThis.fetch = vi.fn().mockResolvedValue({ ok: true, json: async () => mockData }) as unknown as typeof fetch;
|
|
|
|
const result = await connector.execute('list_deals', { limit: 10 });
|
|
expect(result.success).toBe(true);
|
|
expect(result.data).toEqual(mockData);
|
|
});
|
|
});
|
|
|
|
// ── Data/Storage Connectors ────────────────────────────────
|
|
|
|
describe('AirtableConnector', () => {
|
|
let connector: AirtableConnector;
|
|
let originalFetch: typeof globalThis.fetch;
|
|
|
|
beforeEach(() => {
|
|
connector = new AirtableConnector();
|
|
originalFetch = globalThis.fetch;
|
|
});
|
|
|
|
afterEach(() => {
|
|
globalThis.fetch = originalFetch;
|
|
});
|
|
|
|
it('has correct identity', () => {
|
|
expect(connector.id).toBe('airtable');
|
|
expect(connector.name).toBe('Airtable');
|
|
expect(connector.service).toBe('airtable.com');
|
|
expect(connector.authType).toBe('bearer');
|
|
expect(connector.actions).toHaveLength(6);
|
|
});
|
|
|
|
it('actions include expected names', () => {
|
|
const names = connector.actions.map(a => a.name);
|
|
expect(names).toContain('list_bases');
|
|
expect(names).toContain('list_records');
|
|
expect(names).toContain('get_record');
|
|
expect(names).toContain('create_record');
|
|
expect(names).toContain('update_record');
|
|
expect(names).toContain('search_records');
|
|
});
|
|
|
|
it('execute returns error when not connected', async () => {
|
|
const result = await connector.execute('list_bases', {});
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain('Not connected');
|
|
});
|
|
|
|
it('toDefinition maps tools correctly', () => {
|
|
const def = connector.toDefinition('connected');
|
|
expect(def.tools).toContain('connector_airtable_list_bases');
|
|
expect(def.tools).toContain('connector_airtable_create_record');
|
|
expect(def.tools).toHaveLength(6);
|
|
});
|
|
});
|
|
|
|
describe('GitLabConnector', () => {
|
|
let connector: GitLabConnector;
|
|
let originalFetch: typeof globalThis.fetch;
|
|
|
|
beforeEach(() => {
|
|
connector = new GitLabConnector();
|
|
originalFetch = globalThis.fetch;
|
|
});
|
|
|
|
afterEach(() => {
|
|
globalThis.fetch = originalFetch;
|
|
});
|
|
|
|
it('has correct identity', () => {
|
|
expect(connector.id).toBe('gitlab');
|
|
expect(connector.name).toBe('GitLab');
|
|
expect(connector.service).toBe('gitlab.com');
|
|
expect(connector.authType).toBe('bearer');
|
|
expect(connector.actions).toHaveLength(6);
|
|
});
|
|
|
|
it('actions include expected names', () => {
|
|
const names = connector.actions.map(a => a.name);
|
|
expect(names).toContain('list_projects');
|
|
expect(names).toContain('list_issues');
|
|
expect(names).toContain('create_issue');
|
|
expect(names).toContain('list_merge_requests');
|
|
expect(names).toContain('get_file');
|
|
expect(names).toContain('search_code');
|
|
});
|
|
|
|
it('execute returns error when not connected', async () => {
|
|
const result = await connector.execute('list_projects', {});
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain('Not connected');
|
|
});
|
|
|
|
it('toDefinition maps tools correctly', () => {
|
|
const def = connector.toDefinition('connected');
|
|
expect(def.tools).toContain('connector_gitlab_list_projects');
|
|
expect(def.tools).toContain('connector_gitlab_create_issue');
|
|
expect(def.tools).toHaveLength(6);
|
|
});
|
|
|
|
it('supports self-hosted via vault base_url', async () => {
|
|
const vault = createMockVault('gitlab', { value: 'glpat-test', isExpired: false }, {
|
|
'connector:gitlab:base_url': 'https://gitlab.mycompany.com/api/v4',
|
|
});
|
|
await connector.connect(vault);
|
|
|
|
const mockProjects = [{ id: 1, name: 'myproject' }];
|
|
globalThis.fetch = vi.fn().mockResolvedValue({ ok: true, json: async () => mockProjects }) as unknown as typeof fetch;
|
|
|
|
const result = await connector.execute('list_projects', {});
|
|
expect(result.success).toBe(true);
|
|
// Verify the custom base URL was used
|
|
const callUrl = vi.mocked(globalThis.fetch).mock.calls[0][0] as string;
|
|
expect(callUrl).toContain('gitlab.mycompany.com');
|
|
});
|
|
});
|
|
|
|
describe('BitbucketConnector', () => {
|
|
let connector: BitbucketConnector;
|
|
let originalFetch: typeof globalThis.fetch;
|
|
|
|
beforeEach(() => {
|
|
connector = new BitbucketConnector();
|
|
originalFetch = globalThis.fetch;
|
|
});
|
|
|
|
afterEach(() => {
|
|
globalThis.fetch = originalFetch;
|
|
});
|
|
|
|
it('has correct identity', () => {
|
|
expect(connector.id).toBe('bitbucket');
|
|
expect(connector.name).toBe('Bitbucket');
|
|
expect(connector.service).toBe('bitbucket.org');
|
|
expect(connector.authType).toBe('bearer');
|
|
expect(connector.actions).toHaveLength(5);
|
|
});
|
|
|
|
it('actions include expected names', () => {
|
|
const names = connector.actions.map(a => a.name);
|
|
expect(names).toContain('list_repos');
|
|
expect(names).toContain('list_pull_requests');
|
|
expect(names).toContain('get_file');
|
|
expect(names).toContain('create_pull_request');
|
|
expect(names).toContain('list_issues');
|
|
});
|
|
|
|
it('execute returns error when not connected', async () => {
|
|
const result = await connector.execute('list_repos', {});
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain('Not connected');
|
|
});
|
|
|
|
it('toDefinition maps tools correctly', () => {
|
|
const def = connector.toDefinition('connected');
|
|
expect(def.tools).toContain('connector_bitbucket_list_repos');
|
|
expect(def.tools).toContain('connector_bitbucket_create_pull_request');
|
|
expect(def.tools).toHaveLength(5);
|
|
});
|
|
});
|
|
|
|
describe('DropboxConnector', () => {
|
|
let connector: DropboxConnector;
|
|
let originalFetch: typeof globalThis.fetch;
|
|
|
|
beforeEach(() => {
|
|
connector = new DropboxConnector();
|
|
originalFetch = globalThis.fetch;
|
|
});
|
|
|
|
afterEach(() => {
|
|
globalThis.fetch = originalFetch;
|
|
});
|
|
|
|
it('has correct identity', () => {
|
|
expect(connector.id).toBe('dropbox');
|
|
expect(connector.name).toBe('Dropbox');
|
|
expect(connector.service).toBe('dropbox.com');
|
|
expect(connector.authType).toBe('bearer');
|
|
expect(connector.actions).toHaveLength(5);
|
|
});
|
|
|
|
it('actions include expected names', () => {
|
|
const names = connector.actions.map(a => a.name);
|
|
expect(names).toContain('list_folder');
|
|
expect(names).toContain('get_file_metadata');
|
|
expect(names).toContain('search_files');
|
|
expect(names).toContain('download_file');
|
|
expect(names).toContain('upload_file');
|
|
});
|
|
|
|
it('execute returns error when not connected', async () => {
|
|
const result = await connector.execute('list_folder', { path: '' });
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain('Not connected');
|
|
});
|
|
|
|
it('toDefinition maps tools correctly', () => {
|
|
const def = connector.toDefinition('connected');
|
|
expect(def.tools).toContain('connector_dropbox_list_folder');
|
|
expect(def.tools).toContain('connector_dropbox_upload_file');
|
|
expect(def.tools).toHaveLength(5);
|
|
});
|
|
|
|
it('healthCheck uses POST (Dropbox convention)', async () => {
|
|
const vault = createMockVault('dropbox', { value: 'sl.test-token', isExpired: false });
|
|
await connector.connect(vault);
|
|
|
|
globalThis.fetch = vi.fn().mockResolvedValue({
|
|
ok: true,
|
|
json: async () => ({ account_id: 'dbid:ABC', name: { display_name: 'Test' } }),
|
|
}) as unknown as typeof fetch;
|
|
|
|
const health = await connector.healthCheck();
|
|
expect(health.status).toBe('connected');
|
|
// Verify POST method was used
|
|
const fetchCall = vi.mocked(globalThis.fetch).mock.calls[0];
|
|
expect(fetchCall[1].method).toBe('POST');
|
|
});
|
|
});
|
|
|
|
describe('PostgresConnector', () => {
|
|
let connector: PostgresConnector;
|
|
|
|
beforeEach(() => {
|
|
connector = new PostgresConnector();
|
|
});
|
|
|
|
it('has correct identity', () => {
|
|
expect(connector.id).toBe('postgres');
|
|
expect(connector.name).toBe('PostgreSQL');
|
|
expect(connector.service).toBe('local');
|
|
expect(connector.authType).toBe('api_key');
|
|
expect(connector.actions).toHaveLength(4);
|
|
});
|
|
|
|
it('actions include expected names', () => {
|
|
const names = connector.actions.map(a => a.name);
|
|
expect(names).toContain('query');
|
|
expect(names).toContain('execute');
|
|
expect(names).toContain('list_tables');
|
|
expect(names).toContain('describe_table');
|
|
});
|
|
|
|
it('risk levels are correct', () => {
|
|
const queryAction = connector.actions.find(a => a.name === 'query');
|
|
const executeAction = connector.actions.find(a => a.name === 'execute');
|
|
const listAction = connector.actions.find(a => a.name === 'list_tables');
|
|
const describeAction = connector.actions.find(a => a.name === 'describe_table');
|
|
expect(queryAction?.riskLevel).toBe('low');
|
|
expect(executeAction?.riskLevel).toBe('high');
|
|
expect(listAction?.riskLevel).toBe('low');
|
|
expect(describeAction?.riskLevel).toBe('low');
|
|
});
|
|
|
|
it('execute returns error when not connected', async () => {
|
|
const result = await connector.execute('query', { sql: 'SELECT 1' });
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toContain('Not connected');
|
|
});
|
|
|
|
it('execute returns error when pg module is missing', async () => {
|
|
// Mock vault with connection string but pg module will fail to import
|
|
const vault = createMockVault('postgres', { value: 'postgresql://user:pass@localhost:5432/testdb', isExpired: false });
|
|
await connector.connect(vault);
|
|
|
|
// The dynamic import of 'pg' will likely fail in test env
|
|
// The connector should handle this gracefully
|
|
const result = await connector.execute('query', { sql: 'SELECT 1' });
|
|
expect(result.success).toBe(false);
|
|
// Either "pg module not installed" or some other error — both acceptable
|
|
expect(result.error).toBeTruthy();
|
|
});
|
|
|
|
it('toDefinition maps tools correctly', () => {
|
|
const def = connector.toDefinition('connected');
|
|
expect(def.tools).toContain('connector_postgres_query');
|
|
expect(def.tools).toContain('connector_postgres_execute');
|
|
expect(def.tools).toContain('connector_postgres_list_tables');
|
|
expect(def.tools).toContain('connector_postgres_describe_table');
|
|
expect(def.tools).toHaveLength(4);
|
|
});
|
|
});
|