nextog-cli 1.0.0__py3-none-any.whl

nextog/core/runner.py

@@ -0,0 +1,236 @@
+"""
+Test Runner - Orchestrates test execution across all engines
+"""
+
+import asyncio
+from typing import Dict, List, Optional, Any
+from pathlib import Path
+from datetime import datetime
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn
+
+console = Console()
+
+
+class TestRunner:
+    """Orchestrates running tests across multiple engines"""
+    
+    def __init__(self, settings, db, privacy, permissions):
+        self.settings = settings
+        self.db = db
+        self.privacy = privacy
+        self.permissions = permissions
+    
+    def run_all(self, config_path: str, coverage_target: int = 90, parallel: bool = True) -> Dict:
+        """Run all tests from configuration"""
+        config = self._load_config(config_path)
+        results = {
+            "categories": {},
+            "total_coverage": 0,
+            "timestamp": datetime.now().isoformat(),
+            "duration": 0,
+        }
+        
+        engines_config = config.get("engines", {})
+        total_phases = len(engines_config)
+        
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            console=console,
+        ) as progress:
+            overall = progress.add_task("Running all tests...", total=total_phases)
+            
+            for engine_name, engine_config in engines_config.items():
+                progress.update(overall, description=f"Running {engine_name} tests...")
+                
+                engine = self._get_engine(engine_name)
+                if engine:
+                    engine_results = engine.run_tests(**engine_config)
+                    results["categories"][engine_name] = engine_results
+                    results["total_coverage"] = self._calc_coverage(results)
+                
+                progress.advance(overall)
+        
+        results["duration"] = self._calculate_duration(results)
+        self.db.save_test_results(results)
+        self.privacy.record_activity("full_test_run", results)
+        
+        return results
+    
+    def _load_config(self, config_path: str) -> Dict:
+        """Load test configuration from YAML"""
+        import yaml
+        path = Path(config_path)
+        if path.exists():
+            with open(path) as f:
+                return yaml.safe_load(f) or {}
+        return {}
+    
+    def _get_engine(self, name: str):
+        """Get engine instance by name"""
+        engine_map = {
+            "web": ("nextog.engines.web.browser", "WebTestEngine"),
+            "mobile": ("nextog.engines.mobile.android", "MobileTestEngine"),
+            "api": ("nextog.engines.api.rest", "APITestEngine"),
+            "embedded": ("nextog.engines.embedded.hardware", "EmbeddedTestEngine"),
+        }
+        
+        if name not in engine_map:
+            return None
+        
+        module_path, class_name = engine_map[name]
+        import importlib
+        module = importlib.import_module(module_path)
+        engine_class = getattr(module, class_name)
+        return engine_class(self.settings, self.db, self.privacy)
+    
+    def _calc_coverage(self, results: Dict) -> float:
+        """Calculate total coverage from all results"""
+        total = 0
+        count = 0
+        for cat_data in results.get("categories", {}).values():
+            if isinstance(cat_data, dict) and "coverage" in cat_data:
+                total += cat_data["coverage"]
+                count += 1
+        return round(total / count, 2) if count > 0 else 0
+    
+    def _calculate_duration(self, results: Dict) -> float:
+        """Calculate total test duration"""
+        return sum(
+            cat.get("duration", 0) 
+            for cat in results.get("categories", {}).values() 
+            if isinstance(cat, dict)
+        )
+
+
+class ProjectInitializer:
+    """Initialize new nextOG projects"""
+    
+    def __init__(self, settings, db):
+        self.settings = settings
+        self.db = db
+    
+    def create_project(self, name: str, template: str = "full"):
+        """Create a new project structure"""
+        project_dir = Path(name)
+        project_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Create .nextog directory
+        nextog_dir = project_dir / ".nextog"
+        nextog_dir.mkdir(exist_ok=True)
+        (nextog_dir / "tests").mkdir(exist_ok=True)
+        (nextog_dir / "reports").mkdir(exist_ok=True)
+        (nextog_dir / "data").mkdir(exist_ok=True)
+        
+        # Generate config based on template
+        config = self._get_template(template, name)
+        
+        import yaml
+        with open(nextog_dir / "config.yaml", "w") as f:
+            yaml.dump(config, f, default_flow_style=False)
+        
+        # Create initial test files based on template
+        self._create_test_files(nextog_dir / "tests", template)
+    
+    def _get_template(self, template: str, name: str) -> Dict:
+        """Get configuration template"""
+        templates = {
+            "full": {
+                "project": name,
+                "version": "1.0",
+                "engines": {
+                    "web": {"url": "http://localhost:3000", "browser": "chromium", "responsive": True, "accessibility": True},
+                    "api": {"base_url": "http://localhost:3000/api", "spec": "openapi.yaml"},
+                    "mobile": {"platform": "android", "app": "./app.apk"},
+                    "embedded": {"target": "localhost", "protocol": "mqtt"},
+                },
+                "coverage_target": 90,
+                "parallel": True,
+            },
+            "web": {
+                "project": name,
+                "version": "1.0",
+                "engines": {
+                    "web": {"url": "http://localhost:3000", "browser": "chromium", "responsive": True, "accessibility": True},
+                },
+                "coverage_target": 90,
+            },
+            "mobile": {
+                "project": name,
+                "version": "1.0",
+                "engines": {
+                    "mobile": {"platform": "android", "app": "./app.apk"},
+                },
+                "coverage_target": 90,
+            },
+            "api": {
+                "project": name,
+                "version": "1.0",
+                "engines": {
+                    "api": {"base_url": "http://localhost:3000/api", "spec": "openapi.yaml"},
+                },
+                "coverage_target": 90,
+            },
+            "minimal": {
+                "project": name,
+                "version": "1.0",
+                "engines": {},
+                "coverage_target": 60,
+            },
+        }
+        return templates.get(template, templates["full"])
+    
+    def _create_test_files(self, test_dir: Path, template: str):
+        """Create initial test files"""
+        import yaml
+        
+        # Create sample web test
+        if template in ("full", "web"):
+            web_test = {
+                "name": "Sample Web Tests",
+                "url": "http://localhost:3000",
+                "tests": [
+                    {
+                        "name": "Homepage loads",
+                        "type": "smoke",
+                        "steps": [{"action": "navigate", "target": "/"}],
+                        "assertions": [{"type": "status", "expected": 200}],
+                    },
+                    {
+                        "name": "Login form works",
+                        "type": "functional",
+                        "steps": [
+                            {"action": "navigate", "target": "/login"},
+                            {"action": "fill", "target": "#email", "value": "test@test.com"},
+                            {"action": "fill", "target": "#password", "value": "password"},
+                            {"action": "click", "target": "#submit"},
+                        ],
+                        "assertions": [{"type": "url_contains", "expected": "/dashboard"}],
+                    },
+                ],
+            }
+            with open(test_dir / "web_tests.yaml", "w") as f:
+                yaml.dump(web_test, f, default_flow_style=False)
+        
+        # Create sample API test
+        if template in ("full", "api"):
+            api_test = {
+                "name": "Sample API Tests",
+                "base_url": "http://localhost:3000/api",
+                "tests": [
+                    {
+                        "name": "Health check",
+                        "method": "GET",
+                        "endpoint": "/health",
+                        "assertions": [
+                            {"type": "status_code", "expected": 200},
+                            {"type": "response_time", "max_ms": 1000},
+                        ],
+                    },
+                ],
+            }
+            with open(test_dir / "api_tests.yaml", "w") as f:
+                yaml.dump(api_test, f, default_flow_style=False)

nextog/data/__init__.py

@@ -0,0 +1 @@
+"""Data management modules"""

nextog/data/local_db.py

@@ -0,0 +1,367 @@
+"""
+Local Database - SQLite-based local storage for all nextOG data
+Privacy-first: All data stays on the user's machine
+"""
+
+import sqlite3
+import json
+from typing import Dict, List, Optional, Any
+from pathlib import Path
+from datetime import datetime
+from rich.console import Console
+
+console = Console()
+
+
+class LocalDatabase:
+    """Local SQLite database for nextOG CLI"""
+    
+    def __init__(self, db_path: str = None):
+        if db_path is None:
+            db_dir = Path.home() / ".nextog" / "data"
+            db_dir.mkdir(parents=True, exist_ok=True)
+            db_path = str(db_dir / "nextog.db")
+        
+        self.db_path = db_path
+        self._init_db()
+    
+    def _get_conn(self) -> sqlite3.Connection:
+        """Get database connection"""
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        return conn
+    
+    def _init_db(self):
+        """Initialize database tables"""
+        conn = self._get_conn()
+        
+        try:
+            conn.executescript("""
+                -- Test results storage
+                CREATE TABLE IF NOT EXISTS test_results (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    engine TEXT NOT NULL,
+                    project TEXT,
+                    results_json TEXT NOT NULL,
+                    coverage REAL DEFAULT 0,
+                    timestamp TEXT NOT NULL,
+                    duration REAL DEFAULT 0
+                );
+                
+                -- User accounts
+                CREATE TABLE IF NOT EXISTS users (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    username TEXT UNIQUE NOT NULL,
+                    role TEXT NOT NULL DEFAULT 'tester',
+                    email TEXT,
+                    status TEXT DEFAULT 'active',
+                    created_at TEXT NOT NULL,
+                    last_login TEXT
+                );
+                
+                -- Learned patterns
+                CREATE TABLE IF NOT EXISTS patterns (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    pattern_type TEXT NOT NULL,
+                    frequency INTEGER DEFAULT 0,
+                    context TEXT,
+                    related_elements TEXT,
+                    timestamp TEXT NOT NULL
+                );
+                
+                -- Detected elements
+                CREATE TABLE IF NOT EXISTS elements (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    target TEXT NOT NULL,
+                    element_json TEXT NOT NULL,
+                    timestamp TEXT NOT NULL
+                );
+                
+                -- Metadata storage
+                CREATE TABLE IF NOT EXISTS metadata (
+                    key TEXT PRIMARY KEY,
+                    value TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+                
+                -- Optimized test order
+                CREATE TABLE IF NOT EXISTS optimized_tests (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    test_name TEXT NOT NULL,
+                    priority INTEGER DEFAULT 0,
+                    engine TEXT,
+                    timestamp TEXT NOT NULL
+                );
+                
+                -- Activity log
+                CREATE TABLE IF NOT EXISTS activity_log (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    activity_type TEXT NOT NULL,
+                    data_json TEXT,
+                    timestamp TEXT NOT NULL
+                );
+                
+                -- Coverage tracking
+                CREATE TABLE IF NOT EXISTS coverage_history (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    project TEXT,
+                    coverage REAL NOT NULL,
+                    phase TEXT,
+                    timestamp TEXT NOT NULL
+                );
+            """)
+            
+            conn.commit()
+        except Exception as e:
+            console.print(f"[red]Database init error: {e}[/red]")
+        finally:
+            conn.close()
+    
+    # ─── Test Results ──────────────────────────────────────────────
+    
+    def save_test_results(self, results: Dict):
+        """Save test results"""
+        conn = self._get_conn()
+        try:
+            conn.execute(
+                "INSERT INTO test_results (engine, project, results_json, coverage, timestamp, duration) VALUES (?, ?, ?, ?, ?, ?)",
+                (
+                    results.get("engine", "unknown"),
+                    results.get("project", ""),
+                    json.dumps(results.get("results", results), default=str),
+                    results.get("results", {}).get("coverage", 0) if isinstance(results.get("results"), dict) else 0,
+                    results.get("timestamp", datetime.now().isoformat()),
+                    results.get("duration", 0),
+                )
+            )
+            conn.commit()
+        finally:
+            conn.close()
+    
+    def get_latest_results(self, project: str = None) -> Optional[Dict]:
+        """Get latest test results"""
+        conn = self._get_conn()
+        try:
+            if project:
+                row = conn.execute(
+                    "SELECT * FROM test_results WHERE project = ? ORDER BY timestamp DESC LIMIT 1",
+                    (project,)
+                ).fetchone()
+            else:
+                row = conn.execute(
+                    "SELECT * FROM test_results ORDER BY timestamp DESC LIMIT 1"
+                ).fetchone()
+            
+            if row:
+                return {
+                    "id": row["id"],
+                    "engine": row["engine"],
+                    "project": row["project"],
+                    "results": json.loads(row["results_json"]),
+                    "coverage": row["coverage"],
+                    "timestamp": row["timestamp"],
+                }
+        finally:
+            conn.close()
+        return None
+    
+    def get_all_test_results(self) -> List[Dict]:
+        """Get all test results"""
+        conn = self._get_conn()
+        try:
+            rows = conn.execute("SELECT * FROM test_results ORDER BY timestamp DESC").fetchall()
+            return [
+                {
+                    "id": row["id"],
+                    "engine": row["engine"],
+                    "project": row["project"],
+                    "results": json.loads(row["results_json"]),
+                    "coverage": row["coverage"],
+                    "timestamp": row["timestamp"],
+                }
+                for row in rows
+            ]
+        finally:
+            conn.close()
+    
+    def count_test_results(self) -> int:
+        """Count test results"""
+        conn = self._get_conn()
+        try:
+            row = conn.execute("SELECT COUNT(*) FROM test_results").fetchone()
+            return row[0]
+        finally:
+            conn.close()
+    
+    # ─── Users ──────────────────────────────────────────────────────
+    
+    def save_user(self, user: Dict):
+        """Save a user"""
+        conn = self._get_conn()
+        try:
+            conn.execute(
+                "INSERT OR REPLACE INTO users (username, role, email, status, created_at) VALUES (?, ?, ?, ?, ?)",
+                (user["username"], user["role"], user.get("email"), user["status"], user["created_at"])
+            )
+            conn.commit()
+        finally:
+            conn.close()
+    
+    def get_user(self, username: str) -> Optional[Dict]:
+        """Get user by username"""
+        conn = self._get_conn()
+        try:
+            row = conn.execute("SELECT * FROM users WHERE username = ?", (username,)).fetchone()
+            if row:
+                return dict(row)
+        finally:
+            conn.close()
+        return None
+    
+    def get_all_users(self) -> List[Dict]:
+        """Get all users"""
+        conn = self._get_conn()
+        try:
+            rows = conn.execute("SELECT * FROM users").fetchall()
+            return [dict(row) for row in rows]
+        finally:
+            conn.close()
+    
+    def update_last_login(self, username: str):
+        """Update user's last login"""
+        conn = self._get_conn()
+        try:
+            conn.execute(
+                "UPDATE users SET last_login = ? WHERE username = ?",
+                (datetime.now().isoformat(), username)
+            )
+            conn.commit()
+        finally:
+            conn.close()
+    
+    def update_user_role(self, username: str, role: str):
+        """Update user's role"""
+        conn = self._get_conn()
+        try:
+            conn.execute("UPDATE users SET role = ? WHERE username = ?", (role, username))
+            conn.commit()
+        finally:
+            conn.close()
+    
+    def delete_user(self, username: str):
+        """Delete a user"""
+        conn = self._get_conn()
+        try:
+            conn.execute("DELETE FROM users WHERE username = ?", (username,))
+            conn.commit()
+        finally:
+            conn.close()
+    
+    # ─── Patterns ──────────────────────────────────────────────────
+    
+    def save_pattern(self, pattern: Dict):
+        """Save a learned pattern"""
+        conn = self._get_conn()
+        try:
+            conn.execute(
+                "INSERT INTO patterns (pattern_type, frequency, context, related_elements, timestamp) VALUES (?, ?, ?, ?, ?)",
+                (
+                    pattern["type"],
+                    pattern["frequency"],
+                    pattern.get("context", ""),
+                    json.dumps(pattern.get("related_elements", [])),
+                    pattern.get("timestamp", datetime.now().isoformat()),
+                )
+            )
+            conn.commit()
+        finally:
+            conn.close()
+    
+    def count_patterns(self) -> int:
+        """Count stored patterns"""
+        conn = self._get_conn()
+        try:
+            row = conn.execute("SELECT COUNT(*) FROM patterns").fetchone()
+            return row[0]
+        finally:
+            conn.close()
+    
+    # ─── Elements ──────────────────────────────────────────────────
+    
+    def save_elements(self, target: str, elements: List[Dict]):
+        """Save detected elements"""
+        conn = self._get_conn()
+        try:
+            for elem in elements:
+                conn.execute(
+                    "INSERT INTO elements (target, element_json, timestamp) VALUES (?, ?, ?)",
+                    (target, json.dumps(elem, default=str), datetime.now().isoformat())
+                )
+            conn.commit()
+        finally:
+            conn.close()
+    
+    # ─── Metadata ──────────────────────────────────────────────────
+    
+    def save_metadata(self, key: str, value: Any):
+        """Save metadata"""
+        conn = self._get_conn()
+        try:
+            conn.execute(
+                "INSERT OR REPLACE INTO metadata (key, value, updated_at) VALUES (?, ?, ?)",
+                (key, json.dumps(value, default=str), datetime.now().isoformat())
+            )
+            conn.commit()
+        finally:
+            conn.close()
+    
+    def get_metadata(self, key: str) -> Any:
+        """Get metadata value"""
+        conn = self._get_conn()
+        try:
+            row = conn.execute("SELECT value FROM metadata WHERE key = ?", (key,)).fetchone()
+            if row:
+                return json.loads(row[0])
+        finally:
+            conn.close()
+        return None
+    
+    # ─── Optimized Tests ───────────────────────────────────────────
+    
+    def count_optimized_tests(self) -> int:
+        """Count optimized tests"""
+        conn = self._get_conn()
+        try:
+            row = conn.execute("SELECT COUNT(*) FROM optimized_tests").fetchone()
+            return row[0]
+        finally:
+            conn.close()
+    
+    # ─── Export/Purge ──────────────────────────────────────────────
+    
+    def export_all(self) -> Dict:
+        """Export all data"""
+        conn = self._get_conn()
+        try:
+            data = {
+                "test_results": [dict(r) for r in conn.execute("SELECT * FROM test_results").fetchall()],
+                "users": [dict(r) for r in conn.execute("SELECT * FROM users").fetchall()],
+                "patterns": [dict(r) for r in conn.execute("SELECT * FROM patterns").fetchall()],
+                "elements": [dict(r) for r in conn.execute("SELECT * FROM elements").fetchall()],
+                "metadata": {r["key"]: json.loads(r["value"]) for r in conn.execute("SELECT * FROM metadata").fetchall()},
+                "exported_at": datetime.now().isoformat(),
+            }
+            return data
+        finally:
+            conn.close()
+    
+    def purge_all(self):
+        """Delete all data"""
+        conn = self._get_conn()
+        try:
+            tables = ["test_results", "users", "patterns", "elements", "metadata", "optimized_tests", "activity_log", "coverage_history"]
+            for table in tables:
+                conn.execute(f"DELETE FROM {table}")
+            conn.commit()
+        finally:
+            conn.close()

nextog/data/models.py

@@ -0,0 +1,72 @@
+"""Data models using Pydantic for validation"""
+
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+
+
+class TestResult(BaseModel):
+    engine: str
+    total: int = 0
+    passed: int = 0
+    failed: int = 0
+    skipped: int = 0
+    coverage: float = 0.0
+    duration: float = 0.0
+    timestamp: str = Field(default_factory=lambda: datetime.now().isoformat())
+    details: List[Dict[str, Any]] = []
+
+
+class TestCase(BaseModel):
+    name: str
+    test_type: str
+    element: str = ""
+    description: str = ""
+    priority: str = "medium"
+    steps: List[Dict[str, Any]] = []
+    expected_result: str = ""
+    actual_result: str = ""
+    status: str = "pending"
+
+
+class User(BaseModel):
+    username: str
+    role: str = "tester"
+    email: Optional[str] = None
+    status: str = "active"
+    created_at: str = Field(default_factory=lambda: datetime.now().isoformat())
+
+
+class Pattern(BaseModel):
+    type: str
+    frequency: int = 0
+    context: str = ""
+    related_elements: List[str] = []
+    timestamp: str = Field(default_factory=lambda: datetime.now().isoformat())
+
+
+class Element(BaseModel):
+    name: str
+    type: str
+    selector: str = ""
+    description: str = ""
+    priority: str = "medium"
+    visible: bool = True
+    attributes: Dict[str, str] = {}
+
+
+class ProjectConfig(BaseModel):
+    project: str
+    version: str = "1.0"
+    engines: Dict[str, Any] = {}
+    coverage_target: int = 90
+    parallel: bool = True
+
+
+class CoverageData(BaseModel):
+    total_coverage: float = 0.0
+    phases: Dict[str, Any] = {}
+    elements_covered: int = 0
+    elements_total: int = 0
+    timestamp: str = Field(default_factory=lambda: datetime.now().isoformat())
+    project: Optional[str] = None