From 683efb6d8daaa5f1b1a1df9bd679c4673ec1bb60 Mon Sep 17 00:00:00 2001
From: ARCshekin <85334866+ARCshekin@users.noreply.github.com>
Date: Sun, 20 Jul 2025 16:48:47 +0300
Subject: [PATCH 1/5] Update main.py

---
 python/main.py | 396 ++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 328 insertions(+), 68 deletions(-)

diff --git a/python/main.py b/python/main.py
index a9f4328..b1a2c2c 100644
--- a/python/main.py
+++ b/python/main.py
@@ -1,32 +1,78 @@
 import os
 import logging
+import sys
+from this import d
 from typing import List, Any, Optional
+from datetime import datetime
 
 import requests
 from bs4 import BeautifulSoup
 from fastapi import FastAPI
 from pydantic import BaseModel
 from openai import OpenAI
-from selenium import webdriver
+import undetected_chromedriver as uc
 from selenium.webdriver.chrome.options import Options
 
 
-# --- API client setup ---
-API_KEY = os.getenv("OPENAI_API_KEY", "sk-0M12tbkrnKubF86nHyKPKidkqoqfNzei")
-BASE_URL = "https://api.proxyapi.ru/openai/v1"
+# --- Logging Configuration ---
+def setup_logging():
+    """Configure logging with pretty formatting and colors"""
+    # Create formatter with timestamp, level, and message
+    formatter = logging.Formatter(
+        '%(asctime)s | %(levelname)-8s | %(name)-15s | %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    
+    # Console handler with colors
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    console_handler.setLevel(logging.INFO)
+    
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.DEBUG)
+    root_logger.addHandler(console_handler)
+    
+    # Create logger for this module
+    logger = logging.getLogger(__name__)
+    logger.info("🚀 Application started - Logging configured")
+    return logger
+
+
+# Initialize logging
+logger = setup_logging()
+
 
 client = OpenAI(
-    api_key=API_KEY,
-    base_url=BASE_URL
+    api_key="sk-or-vv-332479a389752e4e178aacf60daa99709ebd4dbcaf7ee44b78c3fd2491293534",
+    base_url="https://api.vsegpt.ru/v1",
+
 )
 
 
 def ask_ai(prompt: str) -> str:
-    chat_completion = client.chat.completions.create(
-        model="gpt-4.1-2025-04-14",
-        messages=[{"role": "user", "content": prompt}]
-    )
-    return chat_completion.choices[0].message.content.strip()
+    """Send prompt to AI and return response"""
+    logger.debug("🤖 Sending prompt to AI")
+    try:
+        messages = [
+            {"role": "system", "content": "Ты - большая языковая модель. Отвечай на вопросы пользователя."},
+            {"role": "user", "content": prompt}
+        ]
+        completion = client.chat.completions.create(
+            model='deepseek/deepseek-r1-alt-0528',
+            messages=messages,
+            temperature=0.1,
+            extra_headers={ "X-Title": "Colab Base Example" },
+        )
+        response = completion.choices[0].message.content
+        if response is None:
+            logger.error("❌ AI returned None response")
+            return ""
+        logger.debug("✅ AI response received")
+        return response.strip()
+    except Exception as e:
+        logger.error(f"❌ AI request failed: {e}")
+        raise
 
 
 class APIResponse(BaseModel):
@@ -45,93 +91,307 @@ class WebTestRunner:
     def __init__(self, start_url: str):
         self.current_url = start_url
         self.current_html = ""
+        self.logger = logging.getLogger(f"{__name__}.WebTestRunner")
+
 
     def fetch_page(self, url: str) -> str:
-        # Use headless Selenium to fetch the page HTML
-        chrome_options = Options()
-        chrome_options.add_argument("--headless")
-        chrome_options.add_argument("--no-sandbox")
-        chrome_options.add_argument("--disable-dev-shm-usage")
-        driver = webdriver.Chrome(options=chrome_options)
-        driver.get(url)
-        # Wait for dynamic content if needed (could add explicit waits here)
-        html = driver.page_source
-        self.current_url = driver.current_url
-        self.current_html = html
-        driver.quit()
-        return html
+        """Fetch page HTML using Playwright"""
+        self.logger.info(f"🌐 Fetching page: {url}")
+        # Use Playwright in headless mode to fetch the page HTML (bypasses Cloudflare)
+        try:
+            from playwright.sync_api import sync_playwright
+            html = ""
+            with sync_playwright() as p:
+                browser = p.chromium.launch(headless=True)
+                context = browser.new_context()
+                page = context.new_page()
+                self.logger.debug("📄 Navigating to page...")
+                page.goto(url, timeout=60000)
+                page.wait_for_load_state('networkidle', timeout=60000)
+                html = page.content()
+                browser.close()
+            self.current_url = url
+            self.current_html = html
+            self.logger.info(f"✅ Page fetched successfully ({len(html)} characters)")
+            return html
+        except Exception as e:
+            self.logger.error(f"❌ Failed to fetch page: {e}")
+            raise
+
 
     def check_page(self, url: str, prompts: List[str]) -> List[bool]:
-        # Fetch page via Selenium for JS-rendered content
-        raw_html = self.fetch_page(url)
-        soup = BeautifulSoup(raw_html, 'lxml')
-        results: List[bool] = []
-        for criterion in prompts:
-            # Extract context for AI if no simple rule
-            excerpt = soup
-            c_lower = criterion.lower()
-            # Choose prompt based on criterion template
-            if c_lower.startswith("does") and "exist" in c_lower:
-                instruct = (
-                    "Please answer 'Yes' or 'No'.\n"
-                    f"Criterion: \"{criterion}\" means check if the specified element exists on the page.\n"
-                    "Example: Does logo exist? -> Yes if a logo image is present near the company name.\n"
-                )
-            elif c_lower.startswith("is") and "clickable" in c_lower:
-                instruct = (
-                    "Please answer 'Yes' or 'No'.\n"
-                    f"Criterion: \"{criterion}\" means check if the specified element is clickable (e.g., links, buttons).\n"
-                    "Example: Is 'Submit' button clickable? -> Yes if it responds to clicks.\n"
-                )
-            elif c_lower.startswith("does") and ("attribute" in c_lower or "value" in c_lower):
-                instruct = (
-                    "Please answer 'Yes' or 'No'.\n"
-                    f"Criterion: \"{criterion}\" means check if the element has the given attribute or value.\n"
-                    "Example: Does input have attribute 'placeholder'? -> Yes if the input tag includes placeholder attribute.\n"
-                )
-            else:
-                instruct = (
-                    "Please answer 'Yes' or 'No'.\n"
-                    f"Criterion: \"{criterion}\". Assess based on page content intelligently.\n"
-                )
-            question = f"{instruct}Context: {excerpt}"
-            answer = ask_ai(question).lower()
-            f = open('output.txt', 'w')
-            f.write(answer)
-            f.close()
-            logging.info("AI answer: %s", answer)
-            result = answer.startswith("yes")
-            results.append(result)
-        return results
+        """Check page against given criteria"""
+        self.logger.info(f"🔍 Checking page against {len(prompts)} criteria")
+        try:
+            # Fetch page via Selenium for JS-rendered content
+            raw_html = self.fetch_page(url)
+            soup = BeautifulSoup(raw_html, 'lxml')
+            results: List[bool] = []
+            
+            for i, criterion in enumerate(prompts, 1):
+                self.logger.info(f"🔍 Criterion {i}/{len(prompts)}: {criterion}")
+                # Extract context for AI if no simple rule
+                excerpt = soup
+                c_lower = criterion.lower()
+                # Choose prompt based on criterion template
+                if c_lower.startswith("does") and "exist" in c_lower:
+                    instruct = (
+                        "Please answer 'Yes' or 'No'.\n"
+                        f"Criterion: \"{criterion}\" means check if the specified element exists on the page.\n"
+                        "Example: Does logo exist? -> Yes if a logo image is present near the company name.\n"
+                    )
+                elif c_lower.startswith("is") and "clickable" in c_lower:
+                    instruct = (
+                        "Please answer 'Yes' or 'No'.\n"
+                        f"Criterion: \"{criterion}\" means check if the specified element is clickable (e.g., links, buttons).\n"
+                        "Example: Is 'Submit' button clickable? -> Yes if it responds to clicks.\n"
+                    )
+                elif c_lower.startswith("does") and ("attribute" in c_lower or "value" in c_lower):
+                    instruct = (
+                        "Please answer 'Yes' or 'No'.\n"
+                        f"Criterion: \"{criterion}\" means check if the element has the given attribute or value.\n"
+                        "Example: Does input have attribute 'placeholder'? -> Yes if the input tag includes placeholder attribute.\n"
+                    )
+                else:
+                    instruct = (
+                        "Please answer 'Yes' or 'No'.\n"
+                        f"Criterion: \"{criterion}\". Assess based on page content intelligently.\n"
+                    )
+                question = f"{instruct}Context: {excerpt}"
+                answer = ask_ai(question).lower()
+                self.logger.info(f"🤖 AI answer for '{criterion}': {answer}")
+                result = answer.startswith("yes")
+                results.append(result)
+                self.logger.info(f"✅ Criterion {i} result: {'PASS' if result else 'FAIL'}")
+            
+            self.logger.info(f"📊 Page check completed: {sum(results)}/{len(results)} criteria passed")
+            return results
+        except Exception as e:
+            self.logger.error(f"❌ Error while testing page: {e}")
+            return [False] * len(prompts)
+
+
+    def integration_test(self, test: str, **kwargs) -> tuple[bool, str]:
+        """Run integration test using Playwright"""
+        try:
+            try:
+                from playwright.sync_api import sync_playwright, TimeoutError as PlaywrightTimeoutError
+            except ImportError:
+                self.logger.error("❌ Playwright not installed")
+                return False, "Playwright not installed"
+                
+            import time
+            import json
+
+            def parse_llm_json(text: str) -> dict:
+                try:
+                    start = text.find("<json>")
+                    end = text.find("</json>", start)
+                    if start != -1 and end != -1:
+                        json_str = text[start + 6:end]
+                        return json.loads(json_str)
+                except Exception:
+                    pass
+                raise ValueError("Failed to parse JSON from LLM response")
+
+            self.logger.info(f"🧪 Starting integration test: {test}")
+            self.logger.info(f"📋 Test parameters: {kwargs}")
+            history = []
+            
+            with sync_playwright() as p:
+                browser = p.chromium.launch(headless=True)
+                context = browser.new_context()
+                page = context.new_page()
+                try:
+                    self.logger.info(f"🌐 Navigating to: {self.current_url}")
+                    page.goto(self.current_url, timeout=60000)
+                    page.wait_for_load_state('networkidle', timeout=60000)
+                    self.logger.info("✅ Page loaded successfully")
+
+                    while True:
+                        html = page.content()
+                        # Remove <style>, <script>, <img> tags, <link> tags with as="script" or href containing .css, and <svg>, <meta>, <image> tags
+                        soup = BeautifulSoup(html, 'lxml')
+                        for tag in soup(['style', 'script', 'img', 'svg', 'meta', 'image']):
+                            tag.decompose()
+                        for link_tag in soup.find_all('link', attrs={'as': 'script'}):
+                            link_tag.decompose()
+                        for link_tag in soup.find_all('link', href=True):
+                            if '.css' in link_tag['href']:
+                                link_tag.decompose()
+                        cleaned_html = str(soup)
+                        while '\n\n' in cleaned_html:
+                            cleaned_html = cleaned_html.replace('\n\n', '\n')
+
+                        prompt = f"""
+                            You are simulating an integration test for the following scenario:
+
+                            Test: "{test}"
+                            Parameters: {kwargs}
+
+                            Use this page HTML:
+                            {cleaned_html}  <!-- Limit size to avoid overlength -->
+
+                            Available actions:
+                            - click(css_selector)
+                            - fill(css_selector, text)
+                            - wait(seconds)
+                            - reload()
+
+                            History of actions taken: {history}
+
+                            Your task is to execute the next logical step.
+                            - DO NOT repeat any actions from history.
+                            - Think: which step are we on in the scenario?
+                            - Think: do I need to permorm something on this page or I need to go to other page?
+                            - Think: if it is impossible to perform some action on this page, can you transfer to other page, where needed action can be performed?
+                            - If test is complete or failed, STOP and return result.
+                            - If action cannot be performed, STOP with failure and reason.
+                            - REMEMBER: you can only perform actions on the current page (actions from example can be unusable for this page).
+                            - **IMPORTANT:** Always make sure that all parentheses and quotes in your action strings are properly closed. For example, fill('input[name="username"]', 'arcenty') must have both parentheses and both single/double quotes closed. Do not return incomplete actions.
+
+                            Respond ONLY with JSON inside <json> tags, like:
+                            <json>{{"action": "fill('#login', 'admin')"}}</json>
+                            OR
+                            <json>{{"status": "success", "message": "Login successful"}}</json>
+                            OR
+                            <json>{{"status": "fail", "message": "Password field not found"}}</json>
+                        """
+                        # with open(f'prompt.txt', 'w') as f:
+                        #     f.write(prompt)
+                        try:
+                            self.logger.debug("🤖 Sending prompt to LLM...")
+                            llm_response = ask_ai(prompt)
+                            self.logger.debug(f"🤖 LLM response: {llm_response}")
+                            parsed = parse_llm_json(llm_response)
+                            self.logger.debug(f"🔍 Parsed response: {parsed}")
+                        except Exception as e:
+                            self.logger.error(f"❌ Error with LLM or parsing: {e}")
+                            browser.close()
+                            return False, f"AI or parsing error: {str(e)}"
+
+                        # Handle response
+                        if parsed.get("status") == "success":
+                            message = parsed.get("message", "Success")
+                            self.logger.info(f"✅ Test completed successfully: {message}")
+                            browser.close()
+                            return True, message
+                        if parsed.get("status") == "fail":
+                            message = parsed.get("message", "Failure")
+                            self.logger.error(f"❌ Test failed: {message}")
+                            browser.close()
+                            return False, message
+                        action = parsed.get("action")
+                        if not action:
+                            self.logger.error("❌ No valid action received from LLM")
+                            browser.close()
+                            return False, "No valid action from LLM"
+                        history.append(action)
+                        self.logger.info(f"⚡ Executing action: {action}")
+
+                        try:
+                            if action.startswith("click("):
+                                selector = action[len("click("): -1].strip("'\"")
+                                self.logger.info(f"🖱️ Clicking element: {selector}")
+                                page.click(selector, timeout=10000)
+                                self.logger.info("✅ Click successful")
+                            elif action.startswith("fill("):
+                                inside = action[len("fill("):-1]
+                                if "," not in inside:
+                                    self.logger.error(f"❌ Malformed fill action: {action}")
+                                    browser.close()
+                                    return False, f"Malformed fill action: {action}"
+                                sel, val = inside.split(",", 1)
+                                sel = sel.strip("'\" ")
+                                val = val.strip("'\" ")
+                                self.logger.info(f"✏️ Filling element {sel} with value: {val}")
+                                page.fill(sel, val, timeout=10000)
+                                self.logger.info("✅ Fill successful")
+                            elif action.startswith("wait("):
+                                seconds = float(action[len("wait("): -1])
+                                self.logger.info(f"⏳ Waiting for {seconds} seconds")
+                                time.sleep(seconds)
+                                self.logger.info("✅ Wait completed")
+                            elif action == "reload()":
+                                self.logger.info("🔄 Reloading page")
+                                page.reload(timeout=10000)
+                                self.logger.info("✅ Page reloaded")
+                            else:
+                                self.logger.error(f"❌ Unknown action: {action}")
+                                browser.close()
+                                return False, f"Unknown action: {action}"
+
+                            time.sleep(2)
+                            self.logger.debug(f"📝 Action completed. History: {history}")
+
+                        except PlaywrightTimeoutError as e:
+                            self.logger.error(f"⏰ Action timeout: {action}, error: {e}")
+                            browser.close()
+                            return False, f"Action timeout: {action}, error: {e}"
+                        except Exception as e:
+                            self.logger.error(f"❌ Action failed: {action}, error: {e}")
+                            browser.close()
+                            return False, f"Action failed: {action}, error: {e}"
+                finally:
+                    browser.close()
+                    self.logger.info("🔒 Browser closed")
+            return False, "Error while testing"
+        except Exception as e:
+            self.logger.error(f"❌ Error while testing integration: {e}")
+            return False, "Error while testing"
 
 
 @app.post("/run", response_model=APIResponse)
 def run_tests(data: InputData):
+    """API endpoint to run tests"""
+    logger.info(f"🚀 Starting test run for URL: {data.url}")
+    logger.info(f"📋 Tests to run: {data.tests}")
+    
     runner = WebTestRunner(data.url)
+    a = data.tests
+    unit_tests = []
+    integration_tests = []
+    for test in data.tests:
+        if test.lower().startswith("does") or test.lower().startswith("is"):
+            unit_tests.append(test)
+        else:
+            integration_tests.append(test)
     try:
-        results = runner.check_page(data.url, data.tests)
+        result = []
+        a = runner.check_page(data.url, unit_tests)
+        for b in a:
+            result.append({'test': test, 'result': b, 'comment': 'PASS' if b else 'FAIL'})
+        for integration_test in integration_tests:
+            flag, comment = runner.integration_test(integration_test)
+            result.append({'test': integration_test, 'result': flag, 'comment': comment})
     except Exception as e:
+        logger.error(f"❌ Test execution failed: {e}")
         return APIResponse(data=None)
 
     go_payload = [
         {"test": test, "result": result}
-        for test, result in zip(data.tests, results)
+        for test, result in zip(data.tests, result)
     ]
 
     try:
+        logger.info("📤 Sending results to Go API...")
         post_resp = requests.post(
             "http://go-api:8081/api/results",
             json=go_payload,
             timeout=5
         )
         post_resp.raise_for_status()
+        logger.info("✅ Results sent successfully")
     except Exception as e:
+        logger.error(f"❌ Failed to send results to Go API: {e}")
         return APIResponse(data=None)
 
-    print(go_payload)
+    logger.info(f"📊 Test results: {go_payload}")
     return APIResponse(data=go_payload)
 
 
+
 if __name__ == "__main__":
     import uvicorn
+    logger.info("🌐 Starting FastAPI server on port 3000")
     uvicorn.run(app, host="0.0.0.0", port=3000)

From 55bd1cda0823982479653c1cace4e307ed8755f8 Mon Sep 17 00:00:00 2001
From: ARCshekin <85334866+ARCshekin@users.noreply.github.com>
Date: Sun, 20 Jul 2025 16:55:10 +0300
Subject: [PATCH 2/5] Update requirements.txt

---
 python/requirements.txt | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/python/requirements.txt b/python/requirements.txt
index 2fb95d4..e0842f7 100644
--- a/python/requirements.txt
+++ b/python/requirements.txt
@@ -1,7 +1,11 @@
-fastapi==0.115.12
+fastapi==0.116.1
+requests==2.32.3
 bs4==0.0.2
-lxml==5.4.0
-openai==1.84.0
+beautifulsoup4==4.12.3
+lxml==5.3.0
+pydantic==2.8.2
+openai==1.96.1
+playwright==1.53.0
 pytest==8.4.1
-requests==2.32.3
-selenium==4.34.0
+pytest-mock==3.14.0
+starlette==0.47.1

From 0d340fb97fcb66c2cb5810a93693bfd32b9308c9 Mon Sep 17 00:00:00 2001
From: ARCshekin <85334866+ARCshekin@users.noreply.github.com>
Date: Sun, 20 Jul 2025 16:55:52 +0300
Subject: [PATCH 3/5] Update main.py

---
 python/main.py | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/python/main.py b/python/main.py
index b1a2c2c..de66a5c 100644
--- a/python/main.py
+++ b/python/main.py
@@ -1,18 +1,12 @@
-import os
 import logging
 import sys
 from this import d
 from typing import List, Any, Optional
-from datetime import datetime
-
 import requests
 from bs4 import BeautifulSoup
 from fastapi import FastAPI
 from pydantic import BaseModel
 from openai import OpenAI
-import undetected_chromedriver as uc
-from selenium.webdriver.chrome.options import Options
-
 
 # --- Logging Configuration ---
 def setup_logging():

From 170238a5350502c59d986c9681b0eb8867419af3 Mon Sep 17 00:00:00 2001
From: ARCshekin <85334866+ARCshekin@users.noreply.github.com>
Date: Sun, 20 Jul 2025 16:56:11 +0300
Subject: [PATCH 4/5] Update test_1.py

---
 python/test_1.py | 135 ++++++++++++++++++++++-------------------------
 1 file changed, 64 insertions(+), 71 deletions(-)

diff --git a/python/test_1.py b/python/test_1.py
index d85c58c..fd477d2 100644
--- a/python/test_1.py
+++ b/python/test_1.py
@@ -1,83 +1,76 @@
 import pytest
-from unittest.mock import patch, Mock, MagicMock
 from fastapi.testclient import TestClient
-from main import app, WebTestRunner, ask_ai, API_KEY
-from selenium.common.exceptions import WebDriverException
-
+from unittest.mock import patch, MagicMock
+from main import app, ask_ai, WebTestRunner
 
 client = TestClient(app)
 
-# --- Тестовые HTML-шаблоны ---
-HTML_WITH_LOGIN = """
-<html>
-  <body>
-    <form>
-      <input type="text" />
-      <input type="password" />
-      <button>Submit</button>
-    </form>
-  </body>
-</html>
-"""
-
-HTML_NO_RULE_MATCH = """
-<html>
-  <body>
-    <h2>Добро пожаловать на сайт!</h2>
-    <p>Это просто пример страницы.</p>
-  </body>
-</html>
-"""
+@patch("main.client.chat.completions.create")
+def test_ask_ai_success(mock_create):
+    mock_create.return_value.choices = [MagicMock(message=MagicMock(content="Yes"))]
+    from main import ask_ai
+    response = ask_ai("Does logo exist?")
+    assert response == "Yes"
 
+@patch("main.sync_playwright")
+def test_fetch_page(mock_playwright):
+    mock_browser = MagicMock()
+    mock_context = MagicMock()
+    mock_page = MagicMock()
+    mock_page.content.return_value = "<html><body>Test Page</body></html>"
 
-# --- WebTestRunner Unit Tests ---
-@patch("main.requests.Session.get")
-def test_check_page_with_rules(mock_get):
-    """Тест проверяет обработку критериев через правила без вызова ИИ"""
-    mock_response = Mock()
-    mock_response.status_code = 200
-    mock_response.text = HTML_WITH_LOGIN
-    mock_response.url = "http://example.com"
-    mock_get.return_value = mock_response
+    mock_context.new_page.return_value = mock_page
+    mock_browser.new_context.return_value = mock_context
+    mock_playwright.return_value.__enter__.return_value.chromium.launch.return_value = mock_browser
 
     runner = WebTestRunner("http://example.com")
-    results = runner.check_page("http://example.com", ["Does login field exist?", "Does submit button exist?"])
-
-    assert results == [False, False]  # Оба критерия должны быть True
-
-
-@patch("main.webdriver.Chrome")
-def test_check_page_network_error(mock_webdriver):
-    """Тест обработки сетевых ошибок при загрузке страницы через Selenium"""
-
-    # Настраиваем mock так, чтобы выбрасывалось исключение при вызове .get()
-    mock_driver = MagicMock()
-    mock_driver.get.side_effect = WebDriverException("Network error")
-    mock_webdriver.return_value = mock_driver
-
-    runner = WebTestRunner("http://fail.com")
-
-    with pytest.raises(WebDriverException):
-        runner.check_page("http://fail.com", ["any test"])
-
-
-# --- API Endpoint Tests ---
-@patch("main.requests.post")  # Для мока запроса к Go-сервису
-@patch("main.WebTestRunner.check_page")
-def test_run_tests_success(mock_check_page, mock_post):
-    """Тест успешного выполнения всех операций"""
-    mock_check_page.return_value = [True, False]
-    mock_post.return_value = Mock(status_code=200)
+    html = runner.fetch_page("http://example.com")
+    assert "<body>" in html
+
+@patch("main.ask_ai")
+@patch.object(WebTestRunner, "fetch_page")
+def test_check_page_success(mock_fetch, mock_ai):
+    mock_fetch.return_value = "<html><body><div>Logo</div></body></html>"
+    mock_ai.return_value = "Yes"
+    
+    runner = WebTestRunner("http://example.com")
+    result = runner.check_page("http://example.com", ["Does logo exist?"])
+    assert result == [True]
+
+@patch("main.ask_ai")
+@patch("main.sync_playwright")
+def test_integration_test_success(mock_playwright, mock_ai):
+    # LLM returns successful result immediately
+    mock_ai.return_value = '<json>{"status": "success", "message": "Done"}</json>'
+    
+    mock_browser = MagicMock()
+    mock_context = MagicMock()
+    mock_page = MagicMock()
+    mock_page.content.return_value = "<html><body>OK</body></html>"
+    
+    mock_context.new_page.return_value = mock_page
+    mock_browser.new_context.return_value = mock_context
+    mock_playwright.return_value.__enter__.return_value.chromium.launch.return_value = mock_browser
 
-    payload = {
+    runner = WebTestRunner("http://example.com")
+    runner.current_url = "http://example.com"
+    
+    result, message = runner.integration_test("Login test")
+    assert result is True
+    assert message == "Done"
+
+@patch("main.WebTestRunner.fetch_page")
+@patch("main.ask_ai")
+@patch("main.requests.post")
+def test_run_endpoint(mock_post, mock_ai, mock_fetch):
+    mock_ai.return_value = "Yes"
+    mock_fetch.return_value = "<html><body>Test</body></html>"
+    mock_post.return_value.status_code = 200
+
+    response = client.post("/run", json={
         "url": "http://example.com",
-        "tests": ["login", "welcome"]
-    }
-
-    response = client.post("/run", json=payload)
+        "tests": ["Does logo exist?", "Login with username and password"]
+    })
     assert response.status_code == 200
-    assert response.json()["data"] == [
-        {"test": "login", "result": True},
-        {"test": "welcome", "result": False}
-    ]
-    mock_post.assert_called_once()
+    assert isinstance(response.json()["data"], list)
+

From 43cf350b9c8a638f33aac98bd3b07839c13be275 Mon Sep 17 00:00:00 2001
From: ARCshekin <85334866+ARCshekin@users.noreply.github.com>
Date: Sun, 20 Jul 2025 16:58:16 +0300
Subject: [PATCH 5/5] Update test_1.py

---
 python/test_1.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/python/test_1.py b/python/test_1.py
index fd477d2..28ced74 100644
--- a/python/test_1.py
+++ b/python/test_1.py
@@ -12,7 +12,7 @@ def test_ask_ai_success(mock_create):
     response = ask_ai("Does logo exist?")
     assert response == "Yes"
 
-@patch("main.sync_playwright")
+@patch("playwright.sync_api.sync_playwright")
 def test_fetch_page(mock_playwright):
     mock_browser = MagicMock()
     mock_context = MagicMock()
@@ -38,7 +38,7 @@ def test_check_page_success(mock_fetch, mock_ai):
     assert result == [True]
 
 @patch("main.ask_ai")
-@patch("main.sync_playwright")
+@patch("playwright.sync_api.sync_playwright")
 def test_integration_test_success(mock_playwright, mock_ai):
     # LLM returns successful result immediately
     mock_ai.return_value = '<json>{"status": "success", "message": "Done"}</json>'