external_test.py

# external_test.py - 외부에서 허깅페이스 스페이스 API 테스트
"""
허깅페이스 스페이스가 배포된 후 외부에서 API를 테스트하는 코드
"""

import requests
import time
import json

class HuggingFaceSpaceTest:
    """허깅페이스 스페이스 API 테스트 클래스"""
    
    def __init__(self, space_url):
        """
        space_url: 허깅페이스 스페이스 URL
        예: https://bissal-clovax-tax-chatbot.hf.space
        """
        self.space_url = space_url.rstrip('/')
        self.session = requests.Session()
        
    def test_space_status(self):
        """스페이스 상태 확인"""
        print("🌐 스페이스 상태 확인 중...")
        try:
            response = self.session.get(f"{self.space_url}/", timeout=10)
            if response.status_code == 200:
                print(f"✅ 스페이스 정상 접근 가능: {response.status_code}")
                return True
            else:
                print(f"⚠️ 스페이스 상태 이상: {response.status_code}")
                return False
        except requests.RequestException as e:
            print(f"❌ 스페이스 접근 실패: {e}")
            return False
    
    def test_gradio_api(self, test_query="취득세율이 얼마인가요?"):
        """Gradio API 테스트"""
        print(f"🤖 API 테스트: '{test_query}'")
        
        try:
            # Gradio API 엔드포인트
            api_url = f"{self.space_url}/api/predict"
            
            payload = {
                "data": [test_query, []],  # [message, chat_history]
                "fn_index": 0  # chat 함수의 인덱스
            }
            
            start_time = time.time()
            response = self.session.post(
                api_url,
                json=payload,
                timeout=30
            )
            response_time = time.time() - start_time
            
            if response.status_code == 200:
                result = response.json()
                print(f"✅ API 응답 성공: {response_time:.2f}초")
                
                if 'data' in result:
                    bot_response = result['data'][1][-1][1]  # 마지막 봇 응답
                    print(f"📝 응답 내용 (처음 100자): {bot_response[:100]}...")
                    return {
                        'success': True,
                        'response_time': response_time,
                        'response': bot_response
                    }
                else:
                    print("⚠️ 예상과 다른 응답 형식")
                    return {'success': False, 'error': 'Invalid response format'}
            else:
                print(f"❌ API 호출 실패: {response.status_code}")
                return {'success': False, 'error': f'HTTP {response.status_code}'}
                
        except requests.RequestException as e:
            print(f"❌ API 테스트 실패: {e}")
            return {'success': False, 'error': str(e)}
    
    def test_multiple_queries(self):
        """여러 쿼리 성능 테스트"""
        test_queries = [
            "취득세율이 얼마인가요?",
            "1세대 1주택자 감면 혜택은?",
            "신혼부부 취득세 특례는?",
            "농지 취득세 계산방법은?",
            "다주택자 중과세율은?"
        ]
        
        print(f"🔄 다중 쿼리 테스트: {len(test_queries)}개")
        
        results = []
        total_time = 0
        
        for i, query in enumerate(test_queries, 1):
            print(f"\n📝 테스트 {i}/{len(test_queries)}: {query}")
            
            result = self.test_gradio_api(query)
            results.append(result)
            
            if result['success']:
                total_time += result['response_time']
                print(f"⏱️ 응답시간: {result['response_time']:.2f}초")
            else:
                print(f"❌ 실패: {result['error']}")
            
            # API 부하 방지를 위한 딜레이
            time.sleep(1)
        
        # 성능 요약
        successful_queries = [r for r in results if r['success']]
        success_rate = len(successful_queries) / len(test_queries) * 100
        avg_response_time = total_time / len(successful_queries) if successful_queries else 0
        
        print(f"\n📊 성능 요약:")
        print(f"  성공률: {success_rate:.1f}% ({len(successful_queries)}/{len(test_queries)})")
        print(f"  평균 응답시간: {avg_response_time:.2f}초")
        print(f"  총 테스트 시간: {total_time:.2f}초")
        
        return {
            'success_rate': success_rate,
            'avg_response_time': avg_response_time,
            'total_time': total_time,
            'results': results
        }
    
    def run_full_test(self):
        """전체 테스트 실행"""
        print("🧪 허깅페이스 스페이스 전체 테스트 시작")
        print("=" * 60)
        
        # 1. 스페이스 상태 확인
        if not self.test_space_status():
            print("❌ 스페이스 접근 불가로 테스트 중단")
            return False
        
        print()
        
        # 2. API 기본 테스트
        basic_result = self.test_gradio_api()
        if not basic_result['success']:
            print("❌ 기본 API 테스트 실패로 테스트 중단")
            return False
        
        # 3. 다중 쿼리 성능 테스트
        performance_result = self.test_multiple_queries()
        
        print("\n" + "=" * 60)
        print("🎉 전체 테스트 완료!")
        
        if performance_result['success_rate'] >= 80:
            print("✅ 시스템 정상 작동")
        else:
            print("⚠️ 시스템 성능 저하 감지")
        
        return True

def main():
    """메인 테스트 실행"""
    import sys
    
    if len(sys.argv) > 1:
        space_url = sys.argv[1]
    else:
        # 기본 URL (실제 배포된 스페이스 URL로 변경)
        space_url = "https://bissal-clovax-tax-chatbot.hf.space"
        print(f"기본 URL 사용: {space_url}")
        print("다른 URL 사용시: python external_test.py <SPACE_URL>")
    
    tester = HuggingFaceSpaceTest(space_url)
    tester.run_full_test()

if __name__ == "__main__":
    main()