moai-adk 0.35.1__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-workflow-testing/examples/ai-powered-testing.py

@@ -0,0 +1,294 @@
+"""
+AI-Powered Playwright Testing Examples
+Context7 MCP integration with intelligent test generation
+"""
+
+import asyncio
+import json
+from typing import Dict, List, Optional
+
+from playwright.sync_api import Page, expect, sync_playwright
+
+
+class AITestGenerator:
+    """AI-powered test generation with Context7 integration"""
+
+    def __init__(self, context7_client=None):
+        self.context7_client = context7_client
+        self.ai_patterns = {}
+
+    async def generate_smart_selectors(self, page: Page) -> Dict[str, str]:
+        """Generate intelligent CSS selectors using AI pattern recognition"""
+
+        # Get all interactive elements
+        buttons = page.locator("button").all()
+        page.locator("input").all()
+        page.locator("a[href]").all()
+
+        smart_selectors = {}
+
+        # AI-powered selector generation
+        for i, button in enumerate(buttons):
+            text = button.text_content()
+            if text:
+                # Generate robust selector
+                selector = f"button:has-text('{text.strip()}')"
+                smart_selectors[f"button_{i}"] = {
+                    "selector": selector,
+                    "text": text.strip(),
+                    "type": "button",
+                }
+
+        return smart_selectors
+
+    def generate_test_script(self, selectors: Dict, actions: List[str]) -> str:
+        """Generate automated test script using AI patterns"""
+
+        script_template = '''
+from playwright.sync_api import sync_playwright, expect
+
+def test_ai_generated_workflow():
+    """AI-generated test case with Context7 best practices"""
+
+    with sync_playwright() as p:
+        browser = p.chromium.launch(headless=False)
+        page = browser.new_page()
+
+        # Navigate and wait for content
+        page.goto('https://example.com')
+        page.wait_for_load_state('networkidle')
+
+        # AI-generated interactions
+{interactions}
+
+        # AI-powered assertions
+{assertions}
+
+        browser.close()
+
+if __name__ == "__main__":
+    test_ai_generated_workflow()
+        '''
+
+        interactions = []
+        assertions = []
+
+        for action in actions:
+            if "click" in action:
+                for name, info in selectors.items():
+                    if info["type"] == "button":
+                        interactions.append(f"        page.locator('{info['selector']}').click()")
+                        assertions.append(f"        expect(page.locator('{info['selector']}')).to_be_visible()")
+
+        return script_template.format(interactions="\n".join(interactions), assertions="\n".join(assertions))
+
+
+class Context7TestEnhancer:
+    """Context7 MCP integration for enhanced testing"""
+
+    async def get_latest_patterns(self, topic: str) -> Dict:
+        """Fetch latest Playwright patterns from Context7"""
+
+        # Simulate Context7 integration (would use actual Context7 client)
+        patterns = {
+            "visual_regression": {
+                "screenshot_comparison": True,
+                "ignore_regions": ["dynamic-content", "timestamps"],
+                "threshold": 0.1,
+                "wait_before_capture": 1000,
+            },
+            "cross_browser": {
+                "browsers": ["chromium", "firefox", "webkit"],
+                "viewports": [
+                    {"width": 1920, "height": 1080},
+                    {"width": 375, "height": 667},
+                ],
+                "devices": ["Desktop Chrome", "iPhone 12"],
+            },
+            "performance_testing": {
+                "metrics": ["FCP", "LCP", "TTI", "CLS"],
+                "thresholds": {"FCP": 1.8, "LCP": 2.5, "CLS": 0.1},
+            },
+        }
+
+        return patterns.get(topic, {})
+
+    def apply_context7_patterns(self, test_config: Dict) -> Dict:
+        """Apply Context7 best practices to test configuration"""
+
+        enhanced_config = test_config.copy()
+
+        # Apply Context7 patterns
+        enhanced_config["screenshot_options"] = {
+            "full_page": True,
+            "animations": "disabled",
+            "caret": "hide",
+        }
+
+        enhanced_config["wait_strategies"] = {
+            "networkidle": True,
+            "element_visible": True,
+            "timeout": 10000,
+        }
+
+        return enhanced_config
+
+
+class VisualRegressionTester:
+    """AI-powered visual regression testing"""
+
+    def __init__(self, baseline_dir: str = "./baseline"):
+        self.baseline_dir = baseline_dir
+        self.current_dir = "./current"
+        self.diff_dir = "./diff"
+
+    async def capture_screenshot(self, page: Page, name: str, selector: Optional[str] = None):
+        """Capture intelligent screenshot with Context7 patterns"""
+
+        # Wait for dynamic content
+        page.wait_for_load_state("networkidle")
+        await page.wait_for_timeout(1000)  # Allow animations
+
+        # Capture full page or specific element
+        if selector:
+            element = page.locator(selector)
+            screenshot_path = f"{self.current_dir}/{name}_element.png"
+            element.screenshot(path=screenshot_path)
+        else:
+            screenshot_path = f"{self.current_dir}/{name}_full.png"
+            page.screenshot(path=screenshot_path, full_page=True)
+
+        return screenshot_path
+
+    def compare_screenshots(self, baseline: str, current: str, diff: str) -> Dict:
+        """AI-powered screenshot comparison"""
+
+        # Simulate AI comparison (would use actual image comparison library)
+        comparison_result = {
+            "passed": True,
+            "diff_pixels": 0,
+            "diff_percentage": 0.0,
+            "regions_with_diff": [],
+            "recommendations": [],
+        }
+
+        return comparison_result
+
+
+class CrossBrowserOrchestrator:
+    """AI-coordinated cross-browser testing"""
+
+    def __init__(self):
+        self.browsers = ["chromium", "firefox", "webkit"]
+        self.results = {}
+
+    async def run_cross_browser_test(self, test_script: str) -> Dict:
+        """Execute test across multiple browsers with AI coordination"""
+
+        results = {}
+
+        for browser_name in self.browsers:
+            try:
+                with sync_playwright() as p:
+                    browser = getattr(p, browser_name).launch(headless=True)
+                    page = browser.new_page()
+
+                    # Execute test
+                    test_result = await self.execute_test_in_browser(page, test_script)
+
+                    results[browser_name] = {
+                        "status": "passed",
+                        "execution_time": test_result["time"],
+                        "assertions": test_result["assertions"],
+                        "issues": test_result.get("issues", []),
+                    }
+
+                    browser.close()
+
+            except Exception as e:
+                results[browser_name] = {"status": "failed", "error": str(e)}
+
+        return results
+
+    async def execute_test_in_browser(self, page: Page, test_script: str) -> Dict:
+        """Execute test script and capture results"""
+
+        import time
+
+        start_time = time.time()
+
+        # Simulate test execution
+        page.goto("https://example.com")
+        page.wait_for_load_state("networkidle")
+
+        # Perform assertions
+        assertions_passed = 0
+        assertions_total = 3
+
+        # Basic assertions
+        try:
+            expect(page.locator("h1")).to_be_visible()
+            assertions_passed += 1
+        except Exception:
+            pass
+
+        execution_time = time.time() - start_time
+
+        return {
+            "time": execution_time,
+            "assertions": f"{assertions_passed}/{assertions_total}",
+            "issues": [],
+        }
+
+
+# Example usage and integration
+async def main():
+    """Main AI-powered testing workflow"""
+
+    # Initialize components
+    ai_generator = AITestGenerator()
+    context7_enhancer = Context7TestEnhancer()
+    visual_tester = VisualRegressionTester()
+    cross_browser = CrossBrowserOrchestrator()
+
+    # Enhanced test configuration
+    test_config = {
+        "url": "https://example.com",
+        "browsers": ["chromium", "firefox"],
+        "viewports": [{"width": 1920, "height": 1080}],
+    }
+
+    # Apply Context7 patterns
+    enhanced_config = context7_enhancer.apply_context7_patterns(test_config)
+
+    print("🚀 AI-Powered Testing Workflow Started")
+    print(f"📋 Enhanced Configuration: {json.dumps(enhanced_config, indent=2)}")
+
+    # Generate and execute tests
+    with sync_playwright() as p:
+        browser = p.chromium.launch(headless=True)
+        page = browser.new_page()
+
+        # Navigate and analyze
+        page.goto("https://example.com")
+        page.wait_for_load_state("networkidle")
+
+        # AI-powered analysis
+        smart_selectors = await ai_generator.generate_smart_selectors(page)
+        print(f"🧠 AI Generated Selectors: {len(smart_selectors)} elements found")
+
+        # Visual regression
+        await visual_tester.capture_screenshot(page, "homepage")
+        print("📸 Visual regression screenshot captured")
+
+        browser.close()
+
+    # Cross-browser testing
+    cross_browser_results = await cross_browser.run_cross_browser_test("test_script")
+    print(f"🌐 Cross-browser results: {json.dumps(cross_browser_results, indent=2)}")
+
+    print("✅ AI-powered testing workflow completed")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

moai_adk/templates/.claude/skills/moai-workflow-testing/examples/console_logging.py

@@ -0,0 +1,35 @@
+from playwright.sync_api import sync_playwright
+
+# Example: Capturing console logs during browser automation
+
+url = "http://localhost:5173"  # Replace with your URL
+
+console_logs = []
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    page = browser.new_page(viewport={"width": 1920, "height": 1080})
+
+    # Set up console log capture
+    def handle_console_message(msg):
+        console_logs.append(f"[{msg.type}] {msg.text}")
+        print(f"Console: [{msg.type}] {msg.text}")
+
+    page.on("console", handle_console_message)
+
+    # Navigate to page
+    page.goto(url)
+    page.wait_for_load_state("networkidle")
+
+    # Interact with the page (triggers console logs)
+    page.click("text=Dashboard")
+    page.wait_for_timeout(1000)
+
+    browser.close()
+
+# Save console logs to file
+with open("/mnt/user-data/outputs/console.log", "w") as f:
+    f.write("\n".join(console_logs))
+
+print(f"\nCaptured {len(console_logs)} console messages")
+print("Logs saved to: /mnt/user-data/outputs/console.log")

moai_adk/templates/.claude/skills/moai-workflow-testing/examples/element_discovery.py

@@ -0,0 +1,40 @@
+from playwright.sync_api import sync_playwright
+
+# Example: Discovering buttons and other elements on a page
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    page = browser.new_page()
+
+    # Navigate to page and wait for it to fully load
+    page.goto("http://localhost:5173")
+    page.wait_for_load_state("networkidle")
+
+    # Discover all buttons on the page
+    buttons = page.locator("button").all()
+    print(f"Found {len(buttons)} buttons:")
+    for i, button in enumerate(buttons):
+        text = button.inner_text() if button.is_visible() else "[hidden]"
+        print(f"  [{i}] {text}")
+
+    # Discover links
+    links = page.locator("a[href]").all()
+    print(f"\nFound {len(links)} links:")
+    for link in links[:5]:  # Show first 5
+        text = link.inner_text().strip()
+        href = link.get_attribute("href")
+        print(f"  - {text} -> {href}")
+
+    # Discover input fields
+    inputs = page.locator("input, textarea, select").all()
+    print(f"\nFound {len(inputs)} input fields:")
+    for input_elem in inputs:
+        name = input_elem.get_attribute("name") or input_elem.get_attribute("id") or "[unnamed]"
+        input_type = input_elem.get_attribute("type") or "text"
+        print(f"  - {name} ({input_type})")
+
+    # Take screenshot for visual reference
+    page.screenshot(path="/tmp/page_discovery.png", full_page=True)
+    print("\nScreenshot saved to /tmp/page_discovery.png")
+
+    browser.close()

moai_adk/templates/.claude/skills/moai-workflow-testing/examples/static_html_automation.py

@@ -0,0 +1,34 @@
+import os
+
+from playwright.sync_api import sync_playwright
+
+# Example: Automating interaction with static HTML files using file:// URLs
+
+html_file_path = os.path.abspath("path/to/your/file.html")
+file_url = f"file://{html_file_path}"
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    page = browser.new_page(viewport={"width": 1920, "height": 1080})
+
+    # Navigate to local HTML file
+    page.goto(file_url)
+
+    # Take screenshot
+    page.screenshot(path="/mnt/user-data/outputs/static_page.png", full_page=True)
+
+    # Interact with elements
+    page.click("text=Click Me")
+    page.fill("#name", "John Doe")
+    page.fill("#email", "john@example.com")
+
+    # Submit form
+    page.click('button[type="submit"]')
+    page.wait_for_timeout(500)
+
+    # Take final screenshot
+    page.screenshot(path="/mnt/user-data/outputs/after_submit.png", full_page=True)
+
+    browser.close()
+
+print("Static HTML automation completed!")