nextog-cli 1.0.0__py3-none-any.whl

nextog/engines/mobile/cross.py

@@ -0,0 +1,48 @@
+"""Cross-platform mobile testing - runs tests on both Android and iOS"""
+
+from typing import Dict, List
+from rich.console import Console
+
+console = Console()
+
+
+class CrossPlatformTestEngine:
+    """Run tests across both Android and iOS platforms"""
+    
+    def __init__(self, settings, db, privacy):
+        self.settings = settings
+        self.db = db
+        self.privacy = privacy
+    
+    def run_tests(self, android_app: str = None, ios_app: str = None,
+                  test_suite: str = "default", coverage_target: int = 90) -> Dict:
+        """Run same test suite on both platforms"""
+        results = {
+            "total": 0, "passed": 0, "failed": 0, "skipped": 0,
+            "coverage": 0, "platforms": {}
+        }
+        
+        # Test on Android
+        if android_app:
+            from nextog.engines.mobile.android import MobileTestEngine
+            android_engine = MobileTestEngine(self.settings, self.db, self.privacy)
+            android_results = android_engine.run_tests(android_app, "android")
+            results["platforms"]["android"] = android_results
+        
+        # Test on iOS
+        if ios_app:
+            from nextog.engines.mobile.ios import iOSTestEngine
+            ios_engine = iOSTestEngine(self.settings, self.db, self.privacy)
+            ios_results = ios_engine.run_tests(ios_app, "ios")
+            results["platforms"]["ios"] = ios_results
+        
+        # Aggregate results
+        for platform_data in results["platforms"].values():
+            results["total"] += platform_data.get("total", 0)
+            results["passed"] += platform_data.get("passed", 0)
+            results["failed"] += platform_data.get("failed", 0)
+        
+        if results["total"] > 0:
+            results["coverage"] = round((results["passed"] / results["total"]) * 100, 2)
+        
+        return results

nextog/engines/mobile/ios.py

@@ -0,0 +1,46 @@
+"""iOS Testing Module"""
+
+from typing import Dict
+from nextog.engines.mobile.android import MobileTestEngine
+
+
+class iOSTestEngine(MobileTestEngine):
+    """iOS-specific testing via Appium XCUITest"""
+    
+    def _setup_driver(self, app_path: str, platform: str, device: str):
+        """Setup iOS Appium driver"""
+        try:
+            from appium import webdriver
+            from appium.options.ios import XCUITestOptions
+            
+            options = XCUITestOptions()
+            options.platform_name = "iOS"
+            options.app = app_path
+            options.device_name = device or "iPhone 14"
+            options.automation_name = "XCUITest"
+            options.platform_version = "16.0"
+            options.no_reset = True
+            
+            self.driver = webdriver.Remote("http://127.0.0.1:4723", options=options)
+        except ImportError:
+            raise ImportError("Install Appium-Python-Client for iOS testing")
+    
+    def _test_ui_elements(self) -> Dict:
+        """iOS-specific UI element tests"""
+        results = {"total": 0, "passed": 0, "failed": 0}
+        
+        if not self.driver:
+            return results
+        
+        # Test: XCUIElements exist
+        results["total"] += 1
+        try:
+            elements = self.driver.find_elements("class name", "XCUIElementTypeAny")
+            if len(elements) > 0:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["failed"] += 1
+        
+        return results

nextog/engines/system/__init__.py

@@ -0,0 +1 @@
+"""System testing engines"""

nextog/engines/system/load.py

@@ -0,0 +1,121 @@
+"""Load Testing Engine"""
+
+from typing import Dict
+from concurrent.futures import ThreadPoolExecutor
+import time
+
+
+class LoadTestEngine:
+    """Load testing with configurable scenarios"""
+    
+    def __init__(self, settings, db, privacy):
+        self.settings = settings
+        self.db = db
+        self.privacy = privacy
+    
+    def run_tests(self, target: str, scenario: str = "ramp",
+                  max_users: int = 100, duration: int = 60) -> Dict:
+        """Run load tests"""
+        results = {"total": 0, "passed": 0, "failed": 0, "metrics": {}}
+        
+        if scenario == "ramp":
+            results = self._ramp_test(target, max_users, duration)
+        elif scenario == "constant":
+            results = self._constant_test(target, max_users, duration)
+        elif scenario == "spike":
+            results = self._spike_test(target, max_users)
+        
+        return results
+    
+    def _ramp_test(self, target: str, max_users: int, duration: int) -> Dict:
+        """Gradually increase load"""
+        return self._run_load_scenario(target, max_users, duration, "ramp")
+    
+    def _constant_test(self, target: str, users: int, duration: int) -> Dict:
+        """Constant load"""
+        return self._run_load_scenario(target, users, duration, "constant")
+    
+    def _spike_test(self, target: str, users: int) -> Dict:
+        """Sudden spike in load"""
+        return self._run_load_scenario(target, users, 10, "spike")
+    
+    def _run_load_scenario(self, target: str, max_users: int, duration: int, scenario: str) -> Dict:
+        """Execute a load test scenario"""
+        results = {
+            "total": 1, "passed": 0, "failed": 0,
+            "metrics": {
+                "scenario": scenario,
+                "max_users": max_users,
+                "duration": duration,
+                "total_requests": 0,
+                "successful": 0,
+                "failed": 0,
+                "avg_response_ms": 0,
+                "p95_ms": 0,
+                "p99_ms": 0,
+                "requests_per_sec": 0,
+                "error_rate": 0,
+            }
+        }
+        
+        try:
+            import httpx
+            
+            all_times = []
+            success_count = 0
+            fail_count = 0
+            start_time = time.time()
+            
+            def make_request(_):
+                try:
+                    s = time.time()
+                    resp = httpx.get(target, timeout=10)
+                    elapsed = time.time() - s
+                    return (resp.status_code < 500, elapsed)
+                except Exception:
+                    return (False, 0)
+            
+            with ThreadPoolExecutor(max_workers=min(max_users, 50)) as executor:
+                futures = [executor.submit(make_request, i) for i in range(max_users * 3)]
+                
+                for f in futures:
+                    success, elapsed = f.result()
+                    if success:
+                        success_count += 1
+                    else:
+                        fail_count += 1
+                    if elapsed > 0:
+                        all_times.append(elapsed)
+            
+            total_time = time.time() - start_time
+            total_req = success_count + fail_count
+            
+            sorted_times = sorted(all_times)
+            p95_idx = int(len(sorted_times) * 0.95) if sorted_times else 0
+            p99_idx = int(len(sorted_times) * 0.99) if sorted_times else 0
+            
+            results["metrics"] = {
+                "scenario": scenario,
+                "max_users": max_users,
+                "duration": duration,
+                "total_requests": total_req,
+                "successful": success_count,
+                "failed": fail_count,
+                "avg_response_ms": round(sum(all_times) / len(all_times) * 1000, 2) if all_times else 0,
+                "p95_ms": round(sorted_times[p95_idx] * 1000, 2) if sorted_times else 0,
+                "p99_ms": round(sorted_times[p99_idx] * 1000, 2) if sorted_times else 0,
+                "requests_per_sec": round(total_req / total_time, 2) if total_time > 0 else 0,
+                "error_rate": round((fail_count / total_req * 100), 2) if total_req > 0 else 0,
+            }
+            
+            # Pass if error rate < 5%
+            if results["metrics"]["error_rate"] < 5:
+                results["passed"] = 1
+            else:
+                results["failed"] = 1
+            
+        except Exception as e:
+            results["failed"] = 1
+            results["metrics"]["error"] = str(e)
+        
+        return results

nextog/engines/system/performance.py

@@ -0,0 +1,128 @@
+"""
+Performance Testing Engine - Load, stress, and benchmark testing
+"""
+
+import time
+import asyncio
+from typing import Dict, List
+from concurrent.futures import ThreadPoolExecutor
+import threading
+
+
+class PerformanceTestEngine:
+    """Performance, load, and stress testing"""
+    
+    def __init__(self, settings, db, privacy):
+        self.settings = settings
+        self.db = db
+        self.privacy = privacy
+    
+    def run_tests(self, target: str, concurrent_users: int = 10,
+                  duration: int = 30, ramp_up: int = 5) -> Dict:
+        """Run performance tests"""
+        results = {"total": 0, "passed": 0, "failed": 0, "metrics": {}}
+        
+        # Phase 1: Baseline Performance
+        baseline = self._test_baseline(target)
+        results["metrics"]["baseline"] = baseline
+        
+        # Phase 2: Load Test
+        load = self._test_load(target, concurrent_users, duration)
+        results["metrics"]["load"] = load
+        
+        # Phase 3: Stress Test
+        stress = self._test_stress(target, concurrent_users * 5)
+        results["metrics"]["stress"] = stress
+        
+        # Phase 4: Spike Test
+        spike = self._test_spike(target, concurrent_users * 10)
+        results["metrics"]["spike"] = spike
+        
+        # Calculate overall
+        results["total"] = 4
+        passed = sum(1 for k, v in results["metrics"].items() if v.get("status") == "pass")
+        results["passed"] = passed
+        results["failed"] = results["total"] - passed
+        
+        if results["total"] > 0:
+            results["coverage"] = round((results["passed"] / results["total"]) * 100, 2)
+        
+        return results
+    
+    def _test_baseline(self, target: str) -> Dict:
+        """Test baseline response time"""
+        try:
+            import httpx
+            
+            times = []
+            for _ in range(10):
+                start = time.time()
+                resp = httpx.get(target, timeout=10)
+                elapsed = time.time() - start
+                times.append(elapsed)
+            
+            avg = sum(times) / len(times)
+            p95 = sorted(times)[int(len(times) * 0.95)]
+            p99 = sorted(times)[int(len(times) * 0.99)]
+            
+            status = "pass" if avg < 2.0 else "fail"
+            
+            return {
+                "avg_ms": round(avg * 1000, 2),
+                "p95_ms": round(p95 * 1000, 2),
+                "p99_ms": round(p99 * 1000, 2),
+                "min_ms": round(min(times) * 1000, 2),
+                "max_ms": round(max(times) * 1000, 2),
+                "status": status,
+            }
+        except Exception as e:
+            return {"status": "fail", "error": str(e)}
+    
+    def _test_load(self, target: str, users: int, duration: int) -> Dict:
+        """Simulate concurrent load"""
+        try:
+            import httpx
+            
+            results = {"success": 0, "failed": 0, "total_time": 0, "times": []}
+            
+            def make_request(_):
+                try:
+                    start = time.time()
+                    resp = httpx.get(target, timeout=10)
+                    elapsed = time.time() - start
+                    return {"success": resp.status_code < 500, "time": elapsed}
+                except Exception:
+                    return {"success": False, "time": 0}
+            
+            with ThreadPoolExecutor(max_workers=users) as executor:
+                futures = [executor.submit(make_request, i) for i in range(users * 3)]
+                
+                for future in futures:
+                    result = future.result()
+                    if result["success"]:
+                        results["success"] += 1
+                    else:
+                        results["failed"] += 1
+                    results["times"].append(result["time"])
+            
+            total = results["success"] + results["failed"]
+            success_rate = (results["success"] / total * 100) if total > 0 else 0
+            
+            status = "pass" if success_rate >= 95 else "fail"
+            
+            return {
+                "total_requests": total,
+                "success_rate": round(success_rate, 2),
+                "avg_response_ms": round(sum(results["times"]) / len(results["times"]) * 1000, 2) if results["times"] else 0,
+                "status": status,
+            }
+        except Exception as e:
+            return {"status": "fail", "error": str(e)}
+    
+    def _test_stress(self, target: str, users: int) -> Dict:
+        """Stress test with high concurrency"""
+        return self._test_load(target, users, 10)
+    
+    def _test_spike(self, target: str, users: int) -> Dict:
+        """Spike test - sudden burst of requests"""
+        return self._test_load(target, users, 5)

nextog/engines/system/security.py

@@ -0,0 +1,170 @@
+"""Security Testing Engine"""
+
+from typing import Dict, List
+import time
+
+
+class SecurityTestEngine:
+    """Security and vulnerability testing"""
+    
+    def __init__(self, settings, db, privacy):
+        self.settings = settings
+        self.db = db
+        self.privacy = privacy
+    
+    def run_tests(self, target: str, scan_type: str = "basic") -> Dict:
+        """Run security tests"""
+        results = {"total": 0, "passed": 0, "failed": 0, "vulnerabilities": []}
+        
+        # Test: SSL/TLS
+        results["total"] += 1
+        ssl_ok = self._check_ssl(target)
+        if ssl_ok:
+            results["passed"] += 1
+        else:
+            results["failed"] += 1
+            results["vulnerabilities"].append({"type": "SSL", "severity": "high", "detail": "SSL certificate issue"})
+        
+        # Test: Security Headers
+        results["total"] += 1
+        headers_ok = self._check_security_headers(target)
+        if headers_ok:
+            results["passed"] += 1
+        else:
+            results["failed"] += 1
+            results["vulnerabilities"].append({"type": "Headers", "severity": "medium", "detail": "Missing security headers"})
+        
+        # Test: Open Ports
+        results["total"] += 1
+        ports_ok = self._check_open_ports(target)
+        if ports_ok:
+            results["passed"] += 1
+        else:
+            results["failed"] += 1
+            results["vulnerabilities"].append({"type": "Ports", "severity": "medium", "detail": "Unexpected open ports"})
+        
+        # Test: SQL Injection (basic)
+        results["total"] += 1
+        sqli_ok = self._check_sqli(target)
+        if sqli_ok:
+            results["passed"] += 1
+        else:
+            results["failed"] += 1
+            results["vulnerabilities"].append({"type": "SQLi", "severity": "critical", "detail": "Possible SQL injection"})
+        
+        # Test: XSS (basic)
+        results["total"] += 1
+        xss_ok = self._check_xss(target)
+        if xss_ok:
+            results["passed"] += 1
+        else:
+            results["failed"] += 1
+            results["vulnerabilities"].append({"type": "XSS", "severity": "high", "detail": "Possible XSS vulnerability"})
+        
+        # Test: CORS Configuration
+        results["total"] += 1
+        cors_ok = self._check_cors(target)
+        if cors_ok:
+            results["passed"] += 1
+        else:
+            results["failed"] += 1
+            results["vulnerabilities"].append({"type": "CORS", "severity": "medium", "detail": "Overly permissive CORS"})
+        
+        if results["total"] > 0:
+            results["coverage"] = round((results["passed"] / results["total"]) * 100, 2)
+        
+        return results
+    
+    def _check_ssl(self, target: str) -> bool:
+        """Check SSL/TLS configuration"""
+        try:
+            import ssl
+            import socket
+            
+            hostname = target.replace("http://", "").replace("https://", "").split("/")[0].split(":")[0]
+            context = ssl.create_default_context()
+            
+            with socket.create_connection((hostname, 443), timeout=5) as sock:
+                with context.wrap_socket(sock, server_hostname=hostname) as ssock:
+                    cert = ssock.getpeercert()
+                    return cert is not None
+        except Exception:
+            return False
+    
+    def _check_security_headers(self, target: str) -> bool:
+        """Check for security headers"""
+        try:
+            import httpx
+            resp = httpx.get(target, timeout=10)
+            
+            required = ["x-content-type-options", "x-frame-options"]
+            present = sum(1 for h in required if h in resp.headers)
+            return present >= 1
+        except Exception:
+            return False
+    
+    def _check_open_ports(self, target: str) -> bool:
+        """Check for unexpected open ports"""
+        try:
+            import socket
+            hostname = target.replace("http://", "").replace("https://", "").split("/")[0].split(":")[0]
+            
+            dangerous_ports = [21, 23, 3389, 5900]  # FTP, Telnet, RDP, VNC
+            open_dangerous = []
+            
+            for port in dangerous_ports:
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.settimeout(2)
+                result = sock.connect_ex((hostname, port))
+                sock.close()
+                if result == 0:
+                    open_dangerous.append(port)
+            
+            return len(open_dangerous) == 0
+        except Exception:
+            return True  # Assume safe if can't check
+    
+    def _check_sqli(self, target: str) -> bool:
+        """Basic SQL injection check"""
+        try:
+            import httpx
+            # Test with common SQL injection payloads
+            payloads = ["' OR 1=1 --", "'; DROP TABLE users --"]
+            
+            for payload in payloads:
+                resp = httpx.get(f"{target}?id={payload}", timeout=10)
+                # Check for SQL error messages in response
+                sql_errors = ["sql", "syntax", "mysql", "postgres", "sqlite", "oracle"]
+                content = resp.text.lower()
+                if any(err in content for err in sql_errors):
+                    return False
+            
+            return True
+        except Exception:
+            return True
+    
+    def _check_xss(self, target: str) -> bool:
+        """Basic XSS check"""
+        try:
+            import httpx
+            payload = "<script>alert('xss')</script>"
+            resp = httpx.get(f"{target}?q={payload}", timeout=10)
+            
+            # If payload is reflected without encoding, potential XSS
+            if payload in resp.text:
+                return False
+            return True
+        except Exception:
+            return True
+    
+    def _check_cors(self, target: str) -> bool:
+        """Check CORS configuration"""
+        try:
+            import httpx
+            resp = httpx.options(target, headers={"Origin": "http://evil.com"}, timeout=10)
+            cors = resp.headers.get("access-control-allow-origin", "")
+            
+            # Should not allow all origins
+            return cors != "*"
+        except Exception:
+            return True

nextog/engines/web/__init__.py

@@ -0,0 +1 @@
+"""Web testing engines"""