@agentdb/sdk/examples/test-connection.js

JavaScript SDK for AgentDB database service

/**
 * Test Connection Example
 * 
 * This example tests the basic connectivity and functionality of the SDK
 * without requiring actual database operations. It validates the SDK
 * structure and error handling.
 */

import { 
  DatabaseService,
  DatabaseConnection,
  AgentDBError,
  AuthenticationError,
  ValidationError,
  DatabaseError
} from '../index.js';

function testSDKStructure() {
  console.log('=== Testing SDK Structure ===\n');

  // Test 1: Class constructors
  console.log('1. Testing class constructors...');
  
  try {
    // Should throw validation error for missing parameters
    new DatabaseService();
  } catch (error) {
    if (error instanceof ValidationError) {
      console.log('✓ DatabaseService validation works');
    } else {
      console.log('✗ Unexpected error:', error.message);
    }
  }

  try {
    // Should create successfully
    const service = new DatabaseService('https://example.com', 'test-key');
    console.log('✓ DatabaseService created successfully');
    
    // Test connection creation
    const connection = service.connect('test-token', 'test-db', 'sqlite');
    console.log('✓ DatabaseConnection created successfully');
    
  } catch (error) {
    console.log('✗ Error creating service/connection:', error.message);
  }

  // Test 2: Error class hierarchy
  console.log('\n2. Testing error class hierarchy...');
  
  const errors = [
    new AgentDBError('Test error'),
    new AuthenticationError('Auth error'),
    new ValidationError('Validation error'),
    new DatabaseError('Database error')
  ];

  errors.forEach(error => {
    console.log(`✓ ${error.constructor.name}: ${error instanceof AgentDBError ? 'extends AgentDBError' : 'standalone'}`);
  });

  // Test 3: Parameter validation
  console.log('\n3. Testing parameter validation...');
  
  try {
    const service = new DatabaseService('https://example.com', 'test-key');
    const connection = service.connect('', 'test-db', 'sqlite'); // Empty token
  } catch (error) {
    if (error instanceof ValidationError) {
      console.log('✓ Token validation works');
    }
  }

  try {
    const service = new DatabaseService('https://example.com', 'test-key');
    const connection = service.connect('test-token', '', 'sqlite'); // Empty dbName
  } catch (error) {
    if (error instanceof ValidationError) {
      console.log('✓ Database name validation works');
    }
  }

  try {
    const service = new DatabaseService('https://example.com', 'test-key');
    const connection = service.connect('test-token', 'test-db', 'invalid'); // Invalid dbType
  } catch (error) {
    if (error instanceof ValidationError) {
      console.log('✓ Database type validation works');
    }
  }

  console.log('\n=== SDK Structure Tests Complete ===\n');
}

async function testMockRequests() {
  console.log('=== Testing Mock Requests ===\n');

  const service = new DatabaseService('https://httpbin.org', 'test-key');
  
  // Test 1: Test request structure (using httpbin.org for testing)
  console.log('1. Testing request structure...');
  
  try {
    // This will fail but we can check the request structure
    await service.listDatabases('test-token');
  } catch (error) {
    if (error instanceof AgentDBError) {
      console.log('✓ Request properly structured (expected to fail with httpbin)');
    }
  }

  // Test 2: Test statement validation
  console.log('\n2. Testing statement validation...');
  
  const connection = service.connect('test-token', 'test-db', 'sqlite');
  
  try {
    await connection.execute(null);
  } catch (error) {
    if (error instanceof ValidationError && error.message.includes('statements is required')) {
      console.log('✓ Null statements validation works');
    }
  }

  try {
    await connection.execute([{ params: [] }]); // Missing sql
  } catch (error) {
    if (error instanceof ValidationError && error.message.includes('sql')) {
      console.log('✓ Missing SQL validation works');
    }
  }

  try {
    await connection.execute([{ sql: 'SELECT 1', params: 'invalid' }]); // Invalid params
  } catch (error) {
    if (error instanceof ValidationError && error.message.includes('params')) {
      console.log('✓ Invalid params validation works');
    }
  }

  console.log('\n=== Mock Request Tests Complete ===\n');
}

function testUsagePatterns() {
  console.log('=== Testing Usage Patterns ===\n');

  const service = new DatabaseService('https://api.agentdb.dev', 'test-key');

  // Test 1: Single statement format
  console.log('1. Testing statement formats...');
  
  const connection = service.connect('test-token', 'test-db', 'sqlite');
  
  // These should not throw validation errors
  try {
    // Single statement object
    const singleStmt = { sql: 'SELECT 1', params: [] };
    console.log('✓ Single statement format valid');
    
    // Array of statements
    const multiStmt = [
      { sql: 'SELECT 1', params: [] },
      { sql: 'SELECT 2', params: [1, 2] }
    ];
    console.log('✓ Multiple statements format valid');
    
    // Statement without params
    const noParams = { sql: 'SELECT 1' };
    console.log('✓ Statement without params valid');
    
  } catch (error) {
    console.log('✗ Statement format error:', error.message);
  }

  // Test 2: URL handling
  console.log('\n2. Testing URL handling...');
  
  const urlTests = [
    'https://api.agentdb.dev',
    'https://api.agentdb.dev/',
    'http://localhost:3000',
    'http://localhost:3000/'
  ];

  urlTests.forEach(url => {
    try {
      const testService = new DatabaseService(url, 'test-key');
      console.log(`✓ URL "${url}" handled correctly -> "${testService.baseUrl}"`);
    } catch (error) {
      console.log(`✗ URL "${url}" failed:`, error.message);
    }
  });

  console.log('\n=== Usage Pattern Tests Complete ===\n');
}

function testNewMethods() {
  console.log('=== Testing New Database Management Methods ===\n');

  const service = new DatabaseService('https://api.agentdb.dev', 'test-key');

  // Test 1: Delete database parameter validation
  console.log('1. Testing delete database validation...');

  try {
    // Should not throw - just testing parameter validation
    service.deleteDatabase('', 'test-db', 'sqlite'); // Empty token
  } catch (error) {
    if (error instanceof ValidationError && error.message.includes('token')) {
      console.log('✓ Delete database token validation works');
    }
  }

  try {
    service.deleteDatabase('test-token', '', 'sqlite'); // Empty dbName
  } catch (error) {
    if (error instanceof ValidationError && error.message.includes('dbName')) {
      console.log('✓ Delete database name validation works');
    }
  }

  // Test 2: Rename database parameter validation
  console.log('\n2. Testing rename database validation...');

  try {
    service.renameDatabase('test-token', '', 'new-name', 'sqlite'); // Empty oldDbName
  } catch (error) {
    if (error instanceof ValidationError && error.message.includes('oldDbName')) {
      console.log('✓ Rename database old name validation works');
    }
  }

  try {
    service.renameDatabase('test-token', 'old-name', '', 'sqlite'); // Empty newDbName
  } catch (error) {
    if (error instanceof ValidationError && error.message.includes('newDbName')) {
      console.log('✓ Rename database new name validation works');
    }
  }

  // Test 3: Copy database parameter validation
  console.log('\n3. Testing copy database validation...');

  try {
    service.copyDatabase('', 'source-db', 'sqlite', 'dest-token', 'dest-db'); // Empty sourceToken
  } catch (error) {
    if (error instanceof ValidationError && error.message.includes('sourceToken')) {
      console.log('✓ Copy database source token validation works');
    }
  }

  try {
    service.copyDatabase('source-token', 'source-db', 'invalid-type', 'dest-token', 'dest-db'); // Invalid type
  } catch (error) {
    if (error instanceof ValidationError && error.message.includes('sourceDbType')) {
      console.log('✓ Copy database type validation works');
    }
  }

  // Test 4: Upload URL parameter validation
  console.log('\n4. Testing upload URL validation...');

  try {
    service.getUploadUrl('test-token', '', 'sqlite'); // Empty dbName
  } catch (error) {
    if (error instanceof ValidationError && error.message.includes('dbName')) {
      console.log('✓ Upload URL database name validation works');
    }
  }

  try {
    service.getUploadUrl('test-token', 'test-db', 'invalid'); // Invalid dbType
  } catch (error) {
    if (error instanceof ValidationError && error.message.includes('dbType')) {
      console.log('✓ Upload URL database type validation works');
    }
  }

  // Test 5: Download URL parameter validation
  console.log('\n5. Testing download URL validation...');

  try {
    service.getDownloadUrl('', 'test-db', 'sqlite'); // Empty token
  } catch (error) {
    if (error instanceof ValidationError && error.message.includes('token')) {
      console.log('✓ Download URL token validation works');
    }
  }

  // Test 6: Method existence
  console.log('\n6. Testing method existence...');

  const expectedMethods = [
    'listDatabases',
    'connect',
    'deleteDatabase',
    'renameDatabase',
    'copyDatabase',
    'getUploadUrl',
    'getDownloadUrl'
  ];

  expectedMethods.forEach(method => {
    if (typeof service[method] === 'function') {
      console.log(`✓ Method ${method} exists`);
    } else {
      console.log(`✗ Method ${method} missing`);
    }
  });

  console.log('\n=== New Methods Tests Complete ===\n');
}

// Run all tests
async function runAllTests() {
  console.log('🧪 AgentDB SDK Test Suite\n');

  testSDKStructure();
  await testMockRequests();
  testUsagePatterns();
  testNewMethods();

  console.log('✅ All tests completed!\n');
  console.log('📝 Next steps:');
  console.log('   1. Replace test credentials with real ones');
  console.log('   2. Run basic-usage.js example');
  console.log('   3. Try database-management.js for full management features');
  console.log('   4. Try analytics-duckdb.js for advanced features');
}

runAllTests().catch(console.error);