Error Handling

class DocumentConverterError extends Error {
    constructor(message, statusCode, errorCode = null) {
        super(message);
        this.name = 'DocumentConverterError';
        this.statusCode = statusCode;
        this.errorCode = errorCode;
    }
}

class DocumentConverterClient {
    constructor(baseUrl) {
        this.baseUrl = baseUrl;
    }
    
    async _handleResponse(response) {
        if (response.ok) {
            return await response.json();
        }
        
        let errorMessage = `HTTP ${response.status}`;
        let errorCode = null;
        
        try {
            const errorData = await response.json();
            errorMessage = errorData.detail || errorMessage;
            errorCode = errorData.code;
        } catch (e) {
            // Use default error message if JSON parsing fails
        }
        
        throw new DocumentConverterError(errorMessage, response.status, errorCode);
    }
    
    async createJob(file, outputFormat, options = {}) {
        try {
            const formData = new FormData();
            formData.append('file', file);
            formData.append('output_format', outputFormat);
            
            Object.entries(options).forEach(([key, value]) => {
                formData.append(key, value);
            });
            
            const response = await fetch(`${this.baseUrl}/api/v1/jobs`, {
                method: 'POST',
                body: formData
            });
            
            return await this._handleResponse(response);
        } catch (error) {
            if (error instanceof DocumentConverterError) {
                throw error;
            }
            throw new DocumentConverterError(`Request failed: ${error.message}`, 0);
        }
    }
    
    async getJobStatus(jobId) {
        try {
            const response = await fetch(`${this.baseUrl}/api/v1/jobs/${jobId}`);
            return await this._handleResponse(response);
        } catch (error) {
            if (error instanceof DocumentConverterError) {
                throw error;
            }
            throw new DocumentConverterError(`Request failed: ${error.message}`, 0);
        }
    }
    
    async downloadResult(jobId) {
        try {
            const response = await fetch(`${this.baseUrl}/api/v1/jobs/${jobId}/result`);
            
            if (response.ok) {
                return await response.blob();
            } else {
                await this._handleResponse(response);
            }
        } catch (error) {
            if (error instanceof DocumentConverterError) {
                throw error;
            }
            throw new DocumentConverterError(`Download failed: ${error.message}`, 0);
        }
    }
    
    async waitForCompletion(jobId, timeout = 300000) {
        const startTime = Date.now();
        
        while (Date.now() - startTime < timeout) {
            const status = await this.getJobStatus(jobId);
            
            if (status.status === 'completed') {
                return status;
            } else if (status.status === 'failed') {
                throw new DocumentConverterError(
                    `Job failed: ${status.error_message || 'Unknown error'}`,
                    500
                );
            }
            
            await new Promise(resolve => setTimeout(resolve, 2000));
        }
        
        throw new DocumentConverterError(`Job timeout after ${timeout}ms`, 408);
    }
}

// Usage example
const client = new DocumentConverterClient('http://localhost:8000');

async function convertDocument(file) {
    try {
        // Create job
        const job = await client.createJob(file, 'md');
        console.log('Job created:', job.id);
        
        // Wait for completion
        const completedJob = await client.waitForCompletion(job.id);
        console.log('Job completed:', completedJob.id);
        
        // Download result
        const result = await client.downloadResult(job.id);
        console.log('Result downloaded:', result.size, 'bytes');
        
        return result;
    } catch (error) {
        if (error instanceof DocumentConverterError) {
            console.error('Conversion failed:', error.message);
            console.error('Status code:', error.statusCode);
            if (error.errorCode) {
                console.error('Error code:', error.errorCode);
            }
        } else {
            console.error('Unexpected error:', error);
        }
        throw error;
    }
}

import pytest
import requests

@pytest.fixture
def api_client():
    return DocumentConverterClient("http://localhost:8000")

def test_unsupported_file_type(api_client):
    """Test error handling for unsupported file types"""
    with pytest.raises(DocumentConverterError) as exc_info:
        api_client.create_job("test.xyz", "md")
    
    assert exc_info.value.status_code == 422
    assert "unsupported" in exc_info.value.message.lower()

def test_invalid_output_format(api_client):
    """Test error handling for invalid output format"""
    with pytest.raises(DocumentConverterError) as exc_info:
        api_client.create_job("test.pdf", "invalid")
    
    assert exc_info.value.status_code == 422
    assert exc_info.value.error_code == "VALIDATION_ERROR"

def test_server_error_retry(api_client):
    """Test retry logic for server errors"""
    with patch.object(api_client, '_handle_response') as mock_handle:
        # First call fails with 500, second succeeds
        mock_handle.side_effect = [
            DocumentConverterError("Server error", 500),
            {"id": "job-123", "status": "pending"}
        ]
        
        # Should retry and succeed
        result = api_client.create_job("test.pdf", "md")
        assert result["id"] == "job-123"