feat: able to run test

Author: yuvrajsinh5252

src/commands/test.py

@@ -6,10 +6,17 @@
 auth_manager = Auth()
 solution_manager = SolutionManager(auth_manager.get_session())
 
+map_lang = {
+    "py": "python3",
+    "java": "java",
+    "js": "javascript",
+    "c": "c",
+    "cpp": "cpp"
+}
+
 def test(
     problem: str = typer.Argument(..., help="Problem slug (e.g., 'two-sum')"),
     file: Path = typer.Argument(..., help="Path to solution file"),
-    lang: str = typer.Option("python3", help="Programming language")
 ):
     """Test a solution with LeetCode's test cases"""
     if not auth_manager.is_authenticated:
@@ -23,6 +30,11 @@ def test(
     with open(file, 'r') as f:
         code = f.read()
 
+    lang = map_lang.get(file.suffix[1:])
+    if not lang:
+        typer.echo(typer.style(f"❌ Unsupported file extension: {file.suffix}", fg=typer.colors.RED))
+        raise typer.Exit(1)
+
     typer.echo(typer.style("🧪 Testing solution with LeetCode test cases...", fg=typer.colors.YELLOW))
     result = solution_manager.test_solution(problem, code, lang)
 

src/server/solution_manager.py

@@ -1,10 +1,38 @@
 from typing import Dict, Any
 import time
+import json
+import typer
 
 class SolutionManager:
     def __init__(self, session):
         self.session = session
         self.BASE_URL = "https://leetcode.com"
+        self._clean_session_cookies()
+
+    def _clean_session_cookies(self):
+        """Clean up duplicate cookies"""
+        seen_cookies = {}
+        if not hasattr(self.session, 'cookies'):
+            return
+
+        # Get all cookies
+        all_cookies = list(self.session.cookies)
+
+        # Clear all cookies
+        self.session.cookies.clear()
+
+        # Add back only the most recent cookie for each name
+        for cookie in reversed(all_cookies):
+            if cookie.name not in seen_cookies:
+                seen_cookies[cookie.name] = True
+                self.session.cookies.set_cookie(cookie)
+
+    def _get_csrf_token(self):
+        """Get CSRF token from cookies"""
+        for cookie in self.session.cookies:
+            if cookie.name == 'csrftoken':
+                return cookie.value
+        return "iIf1V3zVGiU5F0neqw63pFm0YlFtk9i531xUBoQe0hZ06pmDGPZ0uJW6vyhr8GEH"
 
     def get_question_data(self, question_identifier: str) -> Dict[str, Any]:
         """Get question details using GraphQL
@@ -55,6 +83,7 @@ def get_question_data(self, question_identifier: str) -> Dict[str, Any]:
 
     def submit_solution(self, title_slug: str, code: str, lang: str = "python3") -> Dict[str, Any]:
         """Submit a solution to LeetCode"""
+
         # First get the question ID
         question_data = self.get_question_data(title_slug)
         question_id = question_data['data']['question']['questionId']
@@ -77,49 +106,112 @@ def submit_solution(self, title_slug: str, code: str, lang: str = "python3") ->
 
         return self.get_submission_result(submission_id)
 
-    def test_solution(self, title_slug: str, code: str, lang: str = "python3") -> Dict[str, Any]:
+    def test_solution(self, title_slug: str, code: str, lang: str = "python3", full: bool = False) -> Dict[str, Any]:
         """Test a solution with LeetCode test cases"""
         try:
-            # First get the question data
-            question_data = self.get_question_data(title_slug)
-            question = question_data['data']['question']
-            question_id = question['questionId']
-            test_cases = question['exampleTestcases']
+            self._clean_session_cookies()
+
+            # Get question data first
+            problem = self.get_question_data(title_slug)
+            question_data = problem.get('data', {}).get('question')
+            if not question_data:
+                return {"success": False, "error": "Question data not found"}
+
+            question_id = question_data['questionId']
+            test_cases = question_data['exampleTestcaseList']
+
+            endpoint = 'submit' if full else 'interpret_solution'
+            sid_key = 'submission_id' if full else 'interpret_id'
 
-            test_url = f"{self.BASE_URL}/problems/{title_slug}/interpret_solution/"
+            url = f"{self.BASE_URL}/problems/{title_slug}/{endpoint}/"
+
+            csrf_token = self.session.cookies.get('csrftoken', '')
+            typer.echo(f"Using CSRF token: {csrf_token}")
 
             headers = {
-                'Accept': 'application/json',
-                'Content-Type': 'application/json',
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
-                'Referer': f'{self.BASE_URL}/problems/{title_slug}/'
+                'referer': f"{self.BASE_URL}/problems/{title_slug}/",
+                'content-type': 'application/json',
+                'x-csrftoken': csrf_token,
+                'x-requested-with': 'XMLHttpRequest',
+                'origin': self.BASE_URL
             }
 
             data = {
-                "lang": lang,
-                "question_id": question_id,
-                "typed_code": code,
-                "data_input": test_cases,
-                "judge_type": "large"
+                'lang': lang,
+                'question_id': str(question_id),
+                'typed_code': code,
+                'data_input': "\n".join(test_cases) if isinstance(test_cases, list) else test_cases,
+                'test_mode': False,
+                'judge_type': 'small'
             }
 
-            response = self.session.post(test_url, json=data, headers=headers, timeout=30)
+            typer.echo(f"Sending request to {url}")
+            response = self.session.post(url, json=data, headers=headers)
 
             if response.status_code != 200:
-                return {
-                    "success": False,
-                    "error": f"Test request failed. Make sure your code is valid {lang} code."
-                }
-
-            interpret_id = response.json().get('interpret_id')
-            if not interpret_id:
-                return {"success": False, "error": "No interpret ID received"}
+                typer.echo(f"Error response: {response.text}", err=True)
+                return {"success": False, "error": f"Request failed with status {response.status_code}"}
 
-            return self.get_test_result(interpret_id)
+            try:
+                result_data = response.json()
+                submission_id = result_data.get(sid_key)
+                if submission_id:
+                    typer.echo(f"Got submission ID: {submission_id}")
+                    return self.get_result(submission_id)
+                else:
+                    typer.echo("No submission ID in response", err=True)
+                    return {"success": False, "error": "No submission ID received"}
+            except ValueError as e:
+                typer.echo(f"Failed to parse response: {response.text}", err=True)
+                return {"success": False, "error": f"Failed to parse response: {str(e)}"}
 
         except Exception as e:
+            typer.echo(f"Test error: {str(e)}", err=True)
             return {"success": False, "error": f"Test error: {str(e)}"}
 
+    def _format_output(self, output) -> str:
+        """Format output that could be string or list"""
+        if isinstance(output, list):
+            return '\n'.join(str(item) for item in output)
+        if isinstance(output, str):
+            return output.strip('[]"')
+        return str(output)
+
+    def get_result(self, submission_id: str, timeout: int = 30) -> Dict[str, Any]:
+        """Poll for results with timeout"""
+        url = f"{self.BASE_URL}/submissions/detail/{submission_id}/check/"
+        typer.echo(f"Polling for results at {url}")
+
+        for i in range(timeout):
+            try:
+                time.sleep(1)
+                typer.echo(f"Attempt {i+1}/{timeout}...")
+
+                response = self.session.get(url)
+                if response.status_code != 200:
+                    continue
+
+                result = response.json()
+                typer.echo(f"Got response: {json.dumps(result, indent=2)}")
+
+                if result.get('state') == 'SUCCESS':
+                    return {
+                        "success": True,
+                        "status": result.get('status_msg', 'Unknown'),
+                        "input": result.get('input', 'N/A'),
+                        "output": self._format_output(result.get('code_answer', [])),
+                        "expected": self._format_output(result.get('expected_code_answer', [])),
+                        "runtime": result.get('status_runtime', 'N/A'),
+                        "memory": result.get('status_memory', 'N/A'),
+                        "total_correct": result.get('total_correct', 0),
+                        "total_testcases": result.get('total_testcases', 0)
+                    }
+            except Exception as e:
+                typer.echo(f"Error checking result: {str(e)}", err=True)
+                continue
+
+        return {"success": False, "error": "Timeout waiting for results"}
+
     def get_submission_result(self, submission_id: str) -> Dict[str, Any]:
         """Poll for submission results"""
         check_url = f"{self.BASE_URL}/submissions/detail/{submission_id}/check/"