refactor of data-service

test-ib.ts

@@ -0,0 +1,194 @@
+/**
+ * Test Interactive Brokers functionality with network monitoring
+ */
+import { Browser } from '@stock-bot/browser';
+import { getRandomProxyURL } from '@stock-bot/proxy';
+
+async function testIBSymbolSummary() {
+  console.log('🚀 Testing Interactive Brokers Symbol Summary with Network Monitoring...');
+
+  try {
+    // Initialize browser
+    await Browser.initialize({
+      headless: true,
+      timeout: 30000,
+      blockResources: true,
+      enableNetworkLogging: true,
+    });
+
+    console.log('✅ Browser initialized');
+
+    // Get a random proxy
+
+    // Create page with proxy
+    const { page, contextId } = await Browser.createPageWithProxy(
+      'https://www.interactivebrokers.com/webrest/search/product-types/summary',
+      'http://doimvbnb-US-rotate:w5fpiwrb9895@p.webshare.io:80'
+    );
+
+    console.log('📄 Page created with proxy');
+
+    // Set up network monitoring
+    let summaryResponse: any = null;
+    let requestCount = 0;
+    let responseCount = 0;
+
+    page.onNetworkEvent(event => {
+      console.log(`📡 Network Event: ${event.type} - ${event.method} ${event.url}`);
+      
+      if (event.type === 'request') {
+        requestCount++;
+        console.log(`   📤 Request #${requestCount}: ${event.method} ${event.url}`);
+        
+        // Log request data for POST requests
+        if (event.requestData) {
+          console.log(`   📝 Request Data: ${event.requestData.substring(0, 200)}...`);
+        }
+      }
+
+      if (event.type === 'response') {
+        responseCount++;
+        console.log(`   📥 Response #${responseCount}: ${event.status} ${event.url}`);
+        
+        // Capture the summary response
+        if (event.url.includes('summary')) {
+          console.log(`   🎯 Found summary response!`);
+          summaryResponse = event.responseData;
+          
+          if (event.responseData) {
+            try {
+              const data = JSON.parse(event.responseData);
+              console.log(`   📊 Summary Data: ${JSON.stringify(data, null, 2)}`);
+            } catch (e) {
+              console.log(`   📊 Raw Response: ${event.responseData.substring(0, 500)}...`);
+            }
+          }
+        }
+      }
+
+      if (event.type === 'failed') {
+        console.log(`   ❌ Failed Request: ${event.url}`);
+      }
+    });
+
+    console.log('🔍 Network monitoring set up, waiting for page to load...');
+
+    // Wait for page to load and capture network activity
+    await page.waitForLoadState('domcontentloaded');
+    console.log('✅ Page loaded');
+
+    // Wait a bit more for any additional network requests
+    await new Promise(resolve => setTimeout(resolve, 3000));
+
+    console.log(`📊 Network Summary:`);
+    console.log(`   📤 Total Requests: ${requestCount}`);
+    console.log(`   📥 Total Responses: ${responseCount}`);
+
+    if (summaryResponse) {
+      console.log('✅ Successfully captured summary response');
+      try {
+        const parsed = JSON.parse(summaryResponse);
+        console.log(`🔢 Total symbols found: ${parsed?.data?.totalCount || 'Unknown'}`);
+        return parsed?.data?.totalCount || 0;
+      } catch (e) {
+        console.log('⚠️  Could not parse response as JSON');
+        return 1; // Indicate success but unknown count
+      }
+    } else {
+      console.log('❌ No summary response captured');
+      return 0;
+    }
+
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+    
+    // Log more details about the error
+    if (error instanceof Error) {
+      console.error('Error details:', {
+        message: error.message,
+        stack: error.stack,
+        name: error.name
+      });
+    }
+    
+    return -1;
+  } finally {
+    try {
+      await Browser.close();
+      console.log('🔒 Browser closed');
+    } catch (closeError) {
+      console.error('Error closing browser:', closeError);
+    }
+  }
+}
+
+async function testWithDifferentProxy() {
+  console.log('\n🔄 Testing with different proxy configuration...');
+  
+  try {
+    await Browser.initialize({
+      headless: true,
+      timeout: 15000,
+      blockResources: false, // Don't block resources for this test
+    });
+
+    // Test without proxy first
+    console.log('🌐 Testing without proxy...');
+    const { page: pageNoProxy, contextId: contextNoProxy } = await Browser.createPageWithProxy(
+      'https://httpbin.org/ip'
+    );
+
+    pageNoProxy.onNetworkEvent(event => {
+      if (event.type === 'response' && event.url.includes('httpbin.org/ip')) {
+        console.log('📍 No proxy IP response:', event.responseData);
+      }
+    });
+
+    await pageNoProxy.waitForLoadState('domcontentloaded');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    await Browser.closeContext(contextNoProxy);
+
+    // Test with proxy
+    console.log('🌐 Testing with proxy...');
+    const { page: pageWithProxy, contextId: contextWithProxy } = await Browser.createPageWithProxy(
+      'https://httpbin.org/ip',
+      'http://doimvbnb-US-rotate:w5fpiwrb9895@p.webshare.io:80'
+    );
+
+    pageWithProxy.onNetworkEvent(event => {
+      if (event.type === 'response' && event.url.includes('httpbin.org/ip')) {
+        console.log('🔄 Proxy IP response:', event.responseData);
+      }
+    });
+
+    await pageWithProxy.waitForLoadState('domcontentloaded');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    await Browser.closeContext(contextWithProxy);
+
+  } catch (error) {
+    console.error('❌ Proxy test failed:', error);
+  } finally {
+    await Browser.close();
+  }
+}
+
+// Run the tests
+async function runTests() {
+  console.log('🧪 Starting IB Network Monitoring Tests\n');
+  
+  // Test 1: Main IB functionality
+  const result = await testIBSymbolSummary();
+  console.log(`\n🏁 Test Result: ${result}`);
+
+  // Test 2: Proxy verification
+  await testWithDifferentProxy();
+
+  console.log('\n✅ All tests completed!');
+}
+
+// Run if this file is executed directly
+if (import.meta.main) {
+  runTests().catch(console.error);
+}
+
+export { testIBSymbolSummary, testWithDifferentProxy };