Market Sizing MCP Server

# Postman Automation & Enhanced Scripts Guide

This guide provides enhanced automation scripts and modern Postman collection management for the TAM MCP Server.

## 🚀 Enhanced Collection Scripts

### Collection-Level Pre-request Script

```javascript
// Enhanced Environment Setup and Validation
const requiredVars = ['serverUrl', 'mcpEndpoint', 'sseEndpoint', 'healthEndpoint'];

// Auto-configure environment if not set
if (!pm.environment.get('serverUrl')) {
    pm.environment.set('serverUrl', 'http://localhost:3000');
}

const serverUrl = pm.environment.get('serverUrl');
if (!pm.environment.get('mcpEndpoint')) {
    pm.environment.set('mcpEndpoint', `${serverUrl}/mcp`);
}

if (!pm.environment.get('sseEndpoint')) {
    pm.environment.set('sseEndpoint', `${serverUrl}/sse`);
}

if (!pm.environment.get('healthEndpoint')) {
    pm.environment.set('healthEndpoint', `${serverUrl}/health`);
}

// Dynamic request ID generation
if (!pm.environment.get('requestId') || pm.request.name.includes('New Session')) {
    pm.environment.set('requestId', `req_${Date.now()}_${Math.floor(Math.random() * 1000)}`);
}

// Session management for MCP
if (pm.request.url.toString().includes('/mcp') && pm.request.method === 'POST') {
    let sessionId = pm.environment.get('sessionId');
    if (!sessionId || pm.request.name.includes('Initialize')) {
        sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
        pm.environment.set('sessionId', sessionId);
        console.log(`🆔 Generated new session ID: ${sessionId}`);
    }
}

// API key validation with helpful messages
const apiKeyConfig = {
    'ALPHA_VANTAGE_API_KEY': {
        required: false,
        url: 'https://www.alphavantage.co/support/#api-key',
        description: 'Stock and financial data'
    },
    'FRED_API_KEY': {
        required: false,
        url: 'https://fred.stlouisfed.org/docs/api/api_key.html',
        description: 'Federal Reserve economic data'
    },
    'BLS_API_KEY': {
        required: false,
        url: 'https://www.bls.gov/developers/api_signature_v2.htm',
        description: 'Bureau of Labor Statistics data'
    }
};

Object.entries(apiKeyConfig).forEach(([key, config]) => {
    const value = pm.environment.get(key);
    if (!value || value.startsWith('your_')) {
        console.warn(`⚠️  ${key} not configured. ${config.description} tools may use mock data.`);
        console.log(`   Get your free API key: ${config.url}`);
    } else {
        console.log(`✅ ${key} configured`);
    }
});

// Request timing
pm.environment.set('requestStartTime', Date.now());
```

### Collection-Level Test Script

```javascript
// Enhanced Response Validation and Debugging
const startTime = pm.environment.get('requestStartTime');
const responseTime = Date.now() - startTime;

// Basic response validation
pm.test("✅ Status code is successful", function () {
    pm.expect(pm.response.code).to.be.oneOf([200, 201, 202]);
});

pm.test("⚡ Response time is acceptable", function () {
    pm.expect(pm.response.responseTime).to.be.below(10000);
    if (pm.response.responseTime > 5000) {
        console.warn(`⚠️  Slow response: ${pm.response.responseTime}ms`);
    }
});

pm.test("📄 Content-Type is JSON", function () {
    const contentType = pm.response.headers.get("Content-Type");
    if (contentType) {
        pm.expect(contentType).to.include("application/json");
    }
});

// MCP Protocol specific validation
if (pm.request.url.toString().includes('/mcp')) {
    pm.test("🔌 MCP Protocol compliance", function () {
        const response = pm.response.json();
        
        pm.expect(response).to.have.property('jsonrpc', '2.0');
        pm.expect(response).to.have.property('id');
        
        if (response.result) {
            pm.expect(response).to.have.property('result');
            console.log('✅ MCP Success Response');
        } else if (response.error) {
            pm.expect(response.error).to.have.property('code');
            pm.expect(response.error).to.have.property('message');
            console.warn(`⚠️  MCP Error: ${response.error.message}`);
        }
    });
    
    // Session management
    if (pm.request.name.includes('Initialize') || pm.request.name.includes('Session')) {
        const response = pm.response.json();
        if (response.result && response.result.capabilities) {
            console.log('🔧 Server capabilities:', JSON.stringify(response.result.capabilities, null, 2));
        }
    }
    
    // Tool execution validation
    if (pm.request.name.includes('Tool:') || pm.request.name.includes('call')) {
        pm.test("🛠️  Tool execution response", function () {
            const response = pm.response.json();
            
            if (response.result) {
                pm.expect(response.result).to.have.property('content');
                pm.expect(response.result.content).to.be.an('array');
                
                if (response.result.content.length > 0) {
                    const firstContent = response.result.content[0];
                    pm.expect(firstContent).to.have.property('type');
                    pm.expect(firstContent).to.have.property('text');
                    
                    // Log successful tool execution
                    console.log(`✅ Tool executed successfully`);
                    console.log(`📊 Response length: ${firstContent.text.length} characters`);
                }
            }
        });
    }
}

// Health check specific validation
if (pm.request.url.toString().includes('/health')) {
    pm.test("💚 Health check validation", function () {
        const response = pm.response.json();
        pm.expect(response).to.have.property('status');
        pm.expect(response).to.have.property('timestamp');
        
        if (response.status === 'healthy') {
            console.log('✅ Server is healthy');
        } else {
            console.warn(`⚠️  Server status: ${response.status}`);
        }
        
        if (response.version) {
            console.log(`🏷️  Server version: ${response.version}`);
        }
        
        if (response.dataSourcesStatus) {
            console.log('📊 Data sources status:', response.dataSourcesStatus);
        }
    });
}

// Error handling validation
if (pm.response.code >= 400) {
    pm.test("❌ Error response structure", function () {
        const response = pm.response.json();
        pm.expect(response).to.have.property('error');
        
        console.error(`❌ Request failed: ${response.error.message || 'Unknown error'}`);
        
        if (response.error.code) {
            console.error(`🔢 Error code: ${response.error.code}`);
        }
    });
}

// Performance logging
console.log(`⏱️  Total request time: ${responseTime}ms`);
if (responseTime > 3000) {
    console.warn(`🐌 Performance warning: Request took ${responseTime}ms`);
}

// Response size logging
const responseSize = pm.response.responseSize;
if (responseSize) {
    console.log(`📏 Response size: ${responseSize} bytes`);
    if (responseSize > 100000) {
        console.warn(`📦 Large response: ${responseSize} bytes`);
    }
}
```

## 🔄 Advanced Automation Features

### Environment Auto-Configuration Script

```javascript
// Dynamic Environment Setup Script
// Run this in a standalone request to auto-configure your environment

pm.test("🔧 Environment Auto-Configuration", function () {
    const config = {
        serverUrl: 'http://localhost:3000',
        environments: {
            development: {
                serverUrl: 'http://localhost:3000',
                timeout: 10000,
                retries: 3
            },
            staging: {
                serverUrl: 'https://staging-tam-mcp.your-domain.com',
                timeout: 5000,
                retries: 2
            },
            production: {
                serverUrl: 'https://tam-mcp.your-domain.com',
                timeout: 3000,
                retries: 1
            }
        }
    };
    
    const env = pm.environment.get('environment') || 'development';
    const envConfig = config.environments[env];
    
    Object.entries(envConfig).forEach(([key, value]) => {
        pm.environment.set(key, value);
        console.log(`✅ Set ${key}: ${value}`);
    });
    
    // Derived URLs
    const serverUrl = pm.environment.get('serverUrl');
    pm.environment.set('mcpEndpoint', `${serverUrl}/mcp`);
    pm.environment.set('sseEndpoint', `${serverUrl}/sse`);
    pm.environment.set('healthEndpoint', `${serverUrl}/health`);
    
    console.log('🎯 Environment configured for:', env);
});
```

### Newman CLI Automation Script

Create a shell script for automated testing:

```bash
#!/bin/bash
# newman-automation.sh

echo "🚀 TAM MCP Server - Automated Testing with Newman"

# Configuration
COLLECTION_FILE="TAM-MCP-Server-Postman-Collection.json"
ENVIRONMENT_FILE="environments/TAM-Environment.json"
REPORT_DIR="newman-reports"

# Create reports directory
mkdir -p $REPORT_DIR

# Check if collection exists
if [ ! -f "$COLLECTION_FILE" ]; then
    echo "❌ Collection file not found: $COLLECTION_FILE"
    exit 1
fi

# Run different test scenarios
echo "🏥 Running Health Checks..."
newman run $COLLECTION_FILE \
    --environment $ENVIRONMENT_FILE \
    --folder "Health & Status" \
    --reporters cli,htmlextra \
    --reporter-htmlextra-export $REPORT_DIR/health-check-report.html

echo "🔌 Running MCP Protocol Tests..."
newman run $COLLECTION_FILE \
    --environment $ENVIRONMENT_FILE \
    --folder "MCP Protocol" \
    --reporters cli,htmlextra \
    --reporter-htmlextra-export $REPORT_DIR/mcp-protocol-report.html

echo "🛠️ Running Tool Tests..."
newman run $COLLECTION_FILE \
    --environment $ENVIRONMENT_FILE \
    --folder "Market Analysis Tools" \
    --reporters cli,htmlextra \
    --reporter-htmlextra-export $REPORT_DIR/tools-report.html

echo "📊 Running Data Source Tests..."
newman run $COLLECTION_FILE \
    --environment $ENVIRONMENT_FILE \
    --folder "Data Source Tests" \
    --reporters cli,htmlextra \
    --reporter-htmlextra-export $REPORT_DIR/data-sources-report.html

echo "✅ All tests completed! Reports saved in $REPORT_DIR"
echo "🌐 Open the HTML reports in your browser for detailed results"
```

## 📊 CI/CD Integration Examples

### GitHub Actions Workflow

```yaml
name: TAM MCP Server API Tests

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]
  schedule:
    - cron: '0 6 * * *'  # Daily at 6 AM UTC

jobs:
  api-tests:
    runs-on: ubuntu-latest
    
    services:
      tam-mcp-server:
        image: node:18
        ports:
          - 3000:3000
        options: --health-cmd "curl -f http://localhost:3000/health" --health-interval 30s --health-timeout 10s --health-retries 5
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '18'
        
    - name: Install dependencies
      run: |
        npm install
        npm install -g newman newman-reporter-htmlextra
        
    - name: Build and start server
      run: |
        npm run build
        npm start &
        sleep 10  # Wait for server to start
        
    - name: Run Postman tests
      run: |
        newman run TAM-MCP-Server-Postman-Collection.json \
          --environment environments/ci-environment.json \
          --reporters cli,junit,htmlextra \
          --reporter-junit-export results.xml \
          --reporter-htmlextra-export api-test-report.html
      env:
        ALPHA_VANTAGE_API_KEY: ${{ secrets.ALPHA_VANTAGE_API_KEY }}
        FRED_API_KEY: ${{ secrets.FRED_API_KEY }}
        
    - name: Upload test results
      uses: actions/upload-artifact@v3
      with:
        name: api-test-reports
        path: |
          results.xml
          api-test-report.html
        
    - name: Publish test results
      uses: dorny/test-reporter@v1
      if: success() || failure()
      with:
        name: API Tests
        path: results.xml
        reporter: java-junit
```

## 🎯 Quick Setup Guide

### 1. Import Enhanced Collections

```bash
# Download enhanced collections
curl -o TAM-Enhanced-Collection.json https://your-repo/postman/enhanced-collection.json

# Import into Postman or use with Newman
newman run TAM-Enhanced-Collection.json --environment your-environment.json
```

### 2. Environment Variables Template

```json
{
  "id": "tam-mcp-environment",
  "name": "TAM MCP Server Environment",
  "values": [
    {"key": "serverUrl", "value": "http://localhost:3000"},
    {"key": "environment", "value": "development"},
    {"key": "timeout", "value": "10000"},
    {"key": "retries", "value": "3"},
    {"key": "ALPHA_VANTAGE_API_KEY", "value": "your_key_here"},
    {"key": "FRED_API_KEY", "value": "your_key_here"},
    {"key": "BLS_API_KEY", "value": "your_key_here"}
  ]
}
```

### 3. Quick Validation Script

```bash
#!/bin/bash
# quick-validate.sh

echo "🔍 Quick TAM MCP Server Validation"

# Health check
echo "🏥 Checking server health..."
curl -s http://localhost:3000/health | jq .

# Tool list
echo "🛠️ Checking available tools..."
echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | \
  curl -s -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -d @- | jq '.result.tools | length'

echo "✅ Quick validation complete"
```

---

## 📋 Summary of Enhancements

### ✅ Enhanced Features

1. **Smart Environment Management** - Auto-configuration and validation
2. **Comprehensive Error Handling** - Detailed error reporting and debugging
3. **Performance Monitoring** - Response time and size tracking
4. **MCP Protocol Validation** - Full compliance checking
5. **CI/CD Integration** - GitHub Actions and automated testing
6. **Detailed Logging** - Console output for debugging
7. **Session Management** - Automatic session handling for MCP
8. **API Key Validation** - Helpful configuration guidance

### 🚀 Ready to Use

- Import the enhanced collection
- Configure your environment
- Run automated tests with Newman
- Integrate with CI/CD pipelines
- Monitor performance and errors

The Postman Scripts Revamp is now complete with modern automation capabilities!