flakeiq 1.0.11

package/python/dashboard.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+import json
+import sqlite3
+import os
+import sys
+import argparse
+from pathlib import Path
+from datetime import datetime, timedelta
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse
+
+DB_PATH = os.environ.get("FLAKE_DB", "flake.db")
+PORT = int(os.environ.get("FLAKE_PORT", "8080"))
+STATIC_DIR = Path(__file__).parent / "web" / "static"
+
+
+class Handler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        parsed = urlparse(self.path)
+        path = parsed.path
+        if path in ("/", "/index.html"):
+            self._serve_file("index.html", "text/html")
+            return
+        if path.startswith("/static/"):
+            fname = path[len("/static/"):]
+            content_types = {".html": "text/html", ".css": "text/css", ".js": "application/javascript"}
+            ext = Path(fname).suffix
+            ct = content_types.get(ext, "application/octet-stream")
+            self._serve_file(fname, ct)
+            return
+        handlers = {
+            "/api/stats": self.api_stats,
+            "/api/flake-rate": self.api_flake_rate,
+            "/api/breakdown": self.api_breakdown,
+            "/api/heatmap": self.api_heatmap,
+            "/api/top-flakes": self.api_top_flakes,
+            "/api/devices": self.api_devices,
+            "/api/by-action": self.api_by_action,
+            "/api/by-platform": self.api_by_platform,
+            "/api/volume": self.api_volume,
+            "/api/duration-dist": self.api_duration_dist,
+            "/api/classification-trend": self.api_classification_trend,
+            "/api/sessions": self.api_sessions,
+            "/api/latest-session": self.api_latest_session,
+        }
+        h = handlers.get(path)
+        if h:
+            h()
+        else:
+            self.send_response(404)
+            self.end_headers()
+
+    def _serve_file(self, filename, content_type):
+        filepath = STATIC_DIR / filename
+        if not filepath.exists():
+            self.send_response(404)
+            self.end_headers()
+            return
+        self.send_response(200)
+        self.send_header("Content-Type", f"{content_type}; charset=utf-8")
+        self.send_header("Cache-Control", "no-cache")
+        self.end_headers()
+        self.wfile.write(filepath.read_bytes())
+
+    def _json(self, data):
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Cache-Control", "no-cache")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.end_headers()
+        self.wfile.write(json.dumps(data).encode())
+
+    def _query(self, sql, params=()):
+        db = sqlite3.connect(DB_PATH)
+        db.row_factory = sqlite3.Row
+        try:
+            return [dict(r) for r in db.execute(sql, params).fetchall()]
+        finally:
+            db.close()
+
+    def _scalar(self, sql, params=()):
+        rows = self._query(sql, params)
+        if rows:
+            return list(rows[0].values())[0]
+        return 0
+
+    def api_stats(self):
+        rows = self._query("""
+            SELECT
+                COUNT(*) as total_runs,
+                SUM(CASE WHEN result != 'passed' THEN 1 ELSE 0 END) as fail_count,
+                SUM(CASE WHEN classification IS NOT NULL THEN 1 ELSE 0 END) as classified_count,
+                SUM(CASE WHEN classification = 'REAL_BUG' THEN 1 ELSE 0 END) as real_bug_count
+            FROM test_runs
+        """)
+        s = rows[0]
+        s["flake_rate"] = round(s["fail_count"] / s["total_runs"] * 100, 1) if s["total_runs"] else 0
+        avg_dur = self._scalar("SELECT CAST(ROUND(AVG(duration_ms / 1000.0)) AS INTEGER) FROM test_runs")
+        s["avg_duration"] = avg_dur or 0
+        dr = self._query("SELECT MIN(DATE(run_at)) as first, MAX(DATE(run_at)) as last FROM test_runs")
+        if dr and dr[0]["first"] and dr[0]["last"]:
+            s["date_range"] = f"{dr[0]['first']} to {dr[0]['last']}"
+        else:
+            s["date_range"] = ""
+        self._json(s)
+
+    def api_flake_rate(self):
+        rows = self._query("""
+            SELECT DATE(run_at) as day,
+                   ROUND(SUM(CASE WHEN result != 'passed' THEN 1 ELSE 0 END) * 100.0 / COUNT(*), 1) as rate
+            FROM test_runs
+            GROUP BY day ORDER BY day LIMIT 60
+        """)
+        self._json(rows)
+
+    def api_breakdown(self):
+        rows = self._query("""
+            SELECT COALESCE(classification, 'UNCLASSIFIED') as classification, COUNT(*) as count
+            FROM test_runs WHERE result != 'passed'
+            GROUP BY classification ORDER BY count DESC
+        """)
+        self._json(rows)
+
+    def api_heatmap(self):
+        rows = self._query("""
+            SELECT DATE(run_at) as day, screen_name as screen,
+                   ROUND(SUM(CASE WHEN result != 'passed' THEN 1 ELSE 0 END) * 100.0 / COUNT(*), 1) as rate
+            FROM test_runs
+            WHERE screen_name IS NOT NULL AND screen_name != ''
+            GROUP BY day, screen
+            HAVING COUNT(*) >= 2
+            ORDER BY day, screen
+        """)
+        self._json(rows)
+
+    def api_top_flakes(self):
+        rows = self._query("""
+            SELECT test_name, platform, screen_name, COUNT(*) as total,
+                   SUM(CASE WHEN result != 'passed' THEN 1 ELSE 0 END) as fail_count,
+                   (SELECT classification FROM test_runs t2
+                    WHERE t2.test_name = t1.test_name AND t2.result != 'passed'
+                    GROUP BY classification ORDER BY COUNT(*) DESC LIMIT 1
+                   ) as common_classification
+            FROM test_runs t1
+            GROUP BY test_name, platform
+            HAVING total >= 2
+            ORDER BY fail_count * 1.0 / total DESC
+            LIMIT 20
+        """)
+        self._json(rows)
+
+    def api_devices(self):
+        rows = self._query("""
+            SELECT device_id, platform, COUNT(*) as total,
+                   SUM(CASE WHEN result != 'passed' THEN 1 ELSE 0 END) as fail_count,
+                   (SELECT classification FROM test_runs t2
+                    WHERE t2.device_id = t1.device_id AND t2.result != 'passed'
+                    GROUP BY classification ORDER BY COUNT(*) DESC LIMIT 1
+                   ) as common_classification
+            FROM test_runs t1
+            GROUP BY device_id
+            HAVING total >= 2
+            ORDER BY fail_count * 1.0 / total DESC
+        """)
+        self._json(rows)
+
+    def api_by_action(self):
+        rows = self._query("""
+            SELECT action_type,
+                   COUNT(*) as total,
+                   SUM(CASE WHEN result != 'passed' THEN 1 ELSE 0 END) as fail_count,
+                   ROUND(SUM(CASE WHEN result != 'passed' THEN 1 ELSE 0 END) * 100.0 / COUNT(*), 1) as rate
+            FROM test_runs
+            WHERE action_type IS NOT NULL AND action_type != ''
+            GROUP BY action_type
+            ORDER BY rate DESC
+        """)
+        self._json(rows)
+
+    def api_by_platform(self):
+        rows = self._query("""
+            SELECT platform,
+                   COUNT(*) as total,
+                   SUM(CASE WHEN result = 'passed' THEN 1 ELSE 0 END) as pass_count,
+                   SUM(CASE WHEN result != 'passed' THEN 1 ELSE 0 END) as fail_count,
+                   ROUND(SUM(CASE WHEN result != 'passed' THEN 1 ELSE 0 END) * 100.0 / COUNT(*), 1) as fail_rate
+            FROM test_runs
+            WHERE platform IS NOT NULL AND platform != ''
+            GROUP BY platform
+            ORDER BY fail_rate DESC
+        """)
+        self._json(rows)
+
+    def api_volume(self):
+        rows = self._query("""
+            SELECT DATE(run_at) as day,
+                   SUM(CASE WHEN result = 'passed' THEN 1 ELSE 0 END) as pass_count,
+                   SUM(CASE WHEN result != 'passed' THEN 1 ELSE 0 END) as fail_count
+            FROM test_runs
+            GROUP BY day ORDER BY day
+        """)
+        self._json(rows)
+
+    def api_duration_dist(self):
+        rows = self._query("""
+            SELECT
+                CASE
+                    WHEN duration_ms < 5000 THEN '0-5s'
+                    WHEN duration_ms < 15000 THEN '5-15s'
+                    WHEN duration_ms < 30000 THEN '15-30s'
+                    WHEN duration_ms < 60000 THEN '30-60s'
+                    WHEN duration_ms < 120000 THEN '60-120s'
+                    ELSE '120s+'
+                END as bucket,
+                COUNT(*) as count
+            FROM test_runs
+            WHERE result != 'passed'
+            GROUP BY bucket
+            ORDER BY MIN(duration_ms)
+        """)
+        self._json(rows)
+
+    def api_classification_trend(self):
+        rows = self._query("""
+            SELECT DATE(run_at) as day, classification, COUNT(*) as count
+            FROM test_runs
+            WHERE result != 'passed' AND classification IS NOT NULL
+            GROUP BY day, classification
+            ORDER BY day
+        """)
+        self._json(rows)
+
+    def api_sessions(self):
+        rows = self._query("""
+            SELECT session_id, platform, device_id,
+                   COUNT(*) as total_runs,
+                   SUM(CASE WHEN result = 'passed' THEN 1 ELSE 0 END) as passed,
+                   SUM(CASE WHEN result != 'passed' THEN 1 ELSE 0 END) as failed,
+                   CAST(ROUND(AVG(duration_ms / 1000.0)) AS INTEGER) as avg_duration_s,
+                   MIN(run_at) as first_run,
+                   MAX(run_at) as last_run
+            FROM test_runs
+            WHERE session_id IS NOT NULL AND session_id != ''
+            GROUP BY session_id
+            ORDER BY last_run DESC
+            LIMIT 20
+        """)
+        self._json(rows)
+
+    def api_latest_session(self):
+        session = self._query("""
+            SELECT session_id, platform, device_id,
+                   COUNT(*) as total_runs,
+                   SUM(CASE WHEN result = 'passed' THEN 1 ELSE 0 END) as passed,
+                   SUM(CASE WHEN result != 'passed' THEN 1 ELSE 0 END) as failed,
+                   CAST(ROUND(AVG(duration_ms / 1000.0)) AS INTEGER) as avg_duration_s
+            FROM test_runs
+            WHERE session_id IS NOT NULL AND session_id != ''
+            GROUP BY session_id
+            ORDER BY MAX(run_at) DESC
+            LIMIT 1
+        """)
+        if not session:
+            self._json({"total_runs": 0, "passed": 0, "failed": 0})
+            return
+        s = session[0]
+        tests = self._query("""
+            SELECT test_name, result, duration_ms, platform, screen_name, classification
+            FROM test_runs
+            WHERE session_id = ?
+            ORDER BY run_at
+        """, (s["session_id"],))
+        s["tests"] = tests
+        self._json(s)
+
+    def log_message(self, format, *args):
+        pass
+
+
+def main():
+    global DB_PATH, PORT
+    parser = argparse.ArgumentParser(description="FlakeIQ dashboard")
+    parser.add_argument("--db", default=None, help="SQLite database path")
+    parser.add_argument("--port", type=int, default=8080, help="HTTP port")
+    parser.add_argument("--host", default="127.0.0.1", help="Bind address")
+    parser.add_argument("--seed", action="store_true", help="Use the seed database (flake-seed.db) instead of real data")
+    parser.add_argument("--open", action="store_true", help="Open browser on start")
+    args = parser.parse_args()
+    if args.seed:
+        seed_path = os.path.join(os.path.dirname(__file__), "flake-seed.db")
+        if os.path.exists(seed_path):
+            DB_PATH = seed_path
+            print(f"Using seed database: {seed_path}")
+        else:
+            print("Seed database not found. Run 'python3 seed.py' first.")
+            sys.exit(1)
+    elif args.db:
+        DB_PATH = args.db
+    PORT = args.port
+    os.environ["FLAKE_DB"] = DB_PATH
+
+    if not os.path.exists(DB_PATH):
+        print(f"Database not found: {DB_PATH}")
+        print("Run 'python3 classify.py flake-results.jsonl' or 'python3 seed.py' first.")
+        sys.exit(1)
+
+    server = HTTPServer((args.host, PORT), Handler)
+    url = f"http://{args.host}:{PORT}"
+    print(f"FlakeIQ dashboard at {url}")
+    if args.open:
+        import webbrowser
+        webbrowser.open(url)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\nShutting down.")
+        server.server_close()
+
+
+if __name__ == "__main__":
+    main()

package/python/requirements.txt

@@ -0,0 +1,2 @@
+bcrypt==4.2.0
+python-jose[cryptography]==3.3.0

package/python/seed.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+import sqlite3
+import json
+import os
+import random
+import sys
+from datetime import datetime, timedelta
+
+DB_PATH = os.environ.get("FLAKE_DB", "flake.db")
+random.seed(42)
+
+SCREENS = ["login", "profile", "form", "list", "alert", "animation", "calendar", "gesture", "media", "signature", "home"]
+DEVICES = [
+    ("Medium_Phone_API_36.0", "android"),
+    ("emulator-5554", "android"),
+    ("iPhone_16_Pro_iOS_18", "ios"),
+    ("iPhone_15_iOS_17", "ios"),
+]
+
+TESTS = [
+    # (test_file, test_name, screen)
+    ("tests/example.spec.ts", "login flow - fill form and submit", "login"),
+    ("tests/example.spec.ts", "login flow - invalid credentials shows error", "login"),
+    ("tests/profile.spec.ts", "edit profile - change name and save", "profile"),
+    ("tests/profile.spec.ts", "toggle notification switches", "profile"),
+    ("tests/profile.spec.ts", "logout from profile screen", "profile"),
+    ("tests/forms.spec.ts", "fill all form fields and submit", "form"),
+    ("tests/forms.spec.ts", "form validation shows errors", "form"),
+    ("tests/lists.spec.ts", "scroll through list items", "list"),
+    ("tests/lists.spec.ts", "pull to refresh list", "list"),
+    ("tests/alerts.spec.ts", "show and dismiss alert dialog", "alert"),
+    ("tests/alerts.spec.ts", "alert with multiple buttons", "alert"),
+    ("tests/animation.spec.ts", "animated element appears", "animation"),
+    ("tests/calendar.spec.ts", "select date from calendar", "calendar"),
+    ("tests/gestures.spec.ts", "swipe between tabs", "gesture"),
+    ("tests/media.spec.ts", "pick image from gallery", "media"),
+    ("tests/signature.spec.ts", "draw and save signature", "signature"),
+    ("tests/home.spec.ts", "home screen loads correctly", "home"),
+]
+
+ACTION_TEMPLATES = {
+    "login": [
+        ["tap(#emailInput)", "fill(#emailInput)", "tap(#passwordInput)", "fill(#passwordInput)", "tap(#loginButton)"],
+        ["tap(#emailInput)", "fill(#emailInput)", "tap(#passwordInput)", "fill(#passwordInput)", "tap(#loginButton)", "waitFor(#homeScreen)"],
+        ["tap(#emailInput)", "fill(#emailInput)", "tap(#passwordInput)", "fill(#passwordInput)", "tap(#loginButton)", "waitForText(Invalid)"],
+    ],
+    "profile": [
+        ["tap(#navProfile)", "waitFor(#profileScreen)", "tap(#editButton)", "fill(#nameInput)", "tap(#saveButton)", "waitForText(Profile updated)"],
+        ["tap(#navProfile)", "waitFor(#profileScreen)", "swipe('up')", "tap(#notificationsSwitch)", "waitForText(Saved)"],
+        ["tap(#navProfile)", "waitFor(#profileScreen)", "swipe('up')", "tap(#logoutButton)", "waitFor(#loginScreen)"],
+    ],
+    "form": [
+        ["tap(#navFormControls)", "waitFor(#formScreen)", "fill(#textInput)", "fill(#emailField)", "fill(#phoneField)", "tap(#submitButton)"],
+        ["tap(#navFormControls)", "waitFor(#formScreen)", "tap(#submitButton)", "waitForText(required)"],
+    ],
+    "list": [
+        ["tap(#navListsDemo)", "waitFor(#listScreen)", "swipe('up')", "swipe('up')", "tap(#listItem_5)"],
+        ["tap(#navListsDemo)", "waitFor(#listScreen)", "swipe('down')", "waitForText(Item 1)"],
+    ],
+    "alert": [
+        ["tap(#navAlertsDemo)", "waitFor(#alertScreen)", "tap(#showAlertButton)", "waitForText(OK)", "tap(#okButton)"],
+        ["tap(#navAlertsDemo)", "waitFor(#alertScreen)", "tap(#multiButtonAlert)", "tap(#cancelButton)"],
+    ],
+    "animation": [
+        ["tap(#navAnimationDemo)", "waitFor(#animationScreen)", "tap(#startAnimation)", "waitForText(Animation complete)"],
+    ],
+    "calendar": [
+        ["tap(#navCalendarDemo)", "waitFor(#calendarScreen)", "tap(#datePicker)", "tap(#day15)", "tap(#confirmButton)"],
+    ],
+    "gesture": [
+        ["tap(#navGesturesDemo)", "waitFor(#gestureScreen)", "swipe('left')", "waitForText(Tab 2)"],
+    ],
+    "media": [
+        ["tap(#navMediaDemo)", "waitFor(#mediaScreen)", "tap(#pickImageButton)", "waitForText(Image selected)"],
+    ],
+    "signature": [
+        ["tap(#navSignatureDemo)", "waitFor(#signatureScreen)", "draw(#canvas)", "tap(#saveSignature)", "waitForText(Signature saved)"],
+    ],
+    "home": [
+        ["waitFor(#homeScreen)", "waitForText(Welcome)", "verify card list visible"],
+    ],
+}
+
+ERROR_TEMPLATES = {
+    "passed": (None, None),
+    "timedOut": [
+        ("actionTimeout 20000ms exceeded", "TIMEOUT_FLAKE", "action timed out waiting for element to appear, likely slow render"),
+        ("Timeout 30000ms exceeded while waiting for #element", "TIMEOUT_FLAKE", "element took longer than expected to become visible"),
+        ("Test timeout of 120000ms exceeded", "TIMEOUT_FLAKE", "full test timeout exceeded, possible memory pressure slow-down"),
+    ],
+    "failed": [
+        ("ExpectError: Expected 1, but received 0", "LOCATOR_FLAKE", "element not found in tree, race condition on navigation"),
+        ("ExpectError: Expected value to be truthy, but received false", "REAL_BUG", "UI state did not match expected value, possible regression"),
+        ("Error: element is not visible", "LOCATOR_FLAKE", "element found but not interactable, viewport calculation mismatch"),
+        ("Error: Method not found", "DEVICE_FLAKE", "device connection lost during action, RPC failure"),
+        ("Error: Could not verify foreground activity", "DEVICE_FLAKE", "ANR dialog or system overlay blocking the app"),
+        ("Error: fill failed - element detached from DOM", "LOCATOR_FLAKE", "stale element reference after navigation"),
+        ("ExpectError: Expected 'Profile updated' but received 'Error saving'", "REAL_BUG", "app returned error state instead of success"),
+    ],
+}
+
+
+def generate_last_actions(screen: str, result: str) -> list[str]:
+    templates = ACTION_TEMPLATES.get(screen, [["tap(#generic)", "waitFor(#generic)"]])
+    base = random.choice(templates)
+    if result == "passed":
+        return base
+    # For failures, return a prefix of actions (the last few before crash)
+    cut = random.randint(1, len(base))
+    return base[:cut]
+
+
+def generate_run_at(base_date: datetime, day_offset: int) -> str:
+    day = base_date + timedelta(days=day_offset)
+    hour = random.randint(7, 22)
+    minute = random.randint(0, 59)
+    second = random.randint(0, 59)
+    return day.replace(hour=hour, minute=minute, second=second).isoformat()
+
+
+def generate_failure_rate(screen: str, platform: str) -> float:
+    rates = {
+        "login": {"android": 0.15, "ios": 0.05},
+        "profile": {"android": 0.12, "ios": 0.04},
+        "form": {"android": 0.08, "ios": 0.03},
+        "list": {"android": 0.20, "ios": 0.06},
+        "alert": {"android": 0.10, "ios": 0.04},
+        "animation": {"android": 0.18, "ios": 0.07},
+        "calendar": {"android": 0.08, "ios": 0.03},
+        "gesture": {"android": 0.22, "ios": 0.08},
+        "media": {"android": 0.25, "ios": 0.10},
+        "signature": {"android": 0.15, "ios": 0.06},
+        "home": {"android": 0.05, "ios": 0.02},
+    }
+    return rates.get(screen, {}).get(platform, 0.10)
+
+
+def seed_database(db_path: str, num_days: int = 30, runs_per_day: int = 5):
+    db = sqlite3.connect(db_path)
+    db.executescript("""
+        DROP TABLE IF EXISTS test_runs;
+        CREATE TABLE test_runs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            test_file TEXT,
+            test_name TEXT,
+            platform TEXT,
+            device_id TEXT,
+            duration_ms INTEGER,
+            result TEXT,
+            error_message TEXT,
+            last_actions TEXT,
+            classification TEXT,
+            classification_reason TEXT,
+            screen_name TEXT,
+            action_type TEXT,
+            session_id TEXT,
+            run_at TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_run_at ON test_runs(run_at);
+        CREATE INDEX IF NOT EXISTS idx_screen ON test_runs(screen_name);
+        CREATE INDEX IF NOT EXISTS idx_result ON test_runs(result);
+        CREATE INDEX IF NOT EXISTS idx_platform ON test_runs(platform);
+    """)
+    cursor = db.cursor()
+
+    base_date = datetime.now() - timedelta(days=num_days)
+    total = 0
+    passed = 0
+    failed = 0
+
+    for day in range(num_days):
+        # run all test files on each day, some multiple times
+        for test_file, test_name, screen in TESTS:
+            for platform_id in [0, 1]:  # 0=android, 1=ios
+                device_id, platform = DEVICES[platform_id]
+                failure_rate = generate_failure_rate(screen, platform)
+
+                for run_num in range(runs_per_day):
+                    # Determine result
+                    is_flake = random.random() < failure_rate
+
+                    if is_flake:
+                        # For flakes, sometimes retry succeeds
+                        is_retry = random.random() < 0.4
+                        if is_retry:
+                            # retry passed after initial failure
+                            result = "passed"
+                            error_msg = None
+                            classification = None
+                            classification_reason = None
+                            passed += 1
+                        else:
+                            result = random.choice(["timedOut", "failed"])
+                            failed += 1
+                    else:
+                        result = "passed"
+                        error_msg = None
+                        classification = None
+                        classification_reason = None
+                        passed += 1
+
+                    # Determine duration
+                    if result == "timedOut":
+                        duration_ms = random.randint(60000, 180000)
+                    elif result == "failed":
+                        duration_ms = random.randint(10000, 55000)
+                    else:
+                        duration_ms = random.randint(3000, 25000)
+
+                    # Error message and classification
+                    if result == "passed":
+                        error_msg = ""
+                        classification = None
+                        classification_reason = None
+                        last_actions = generate_last_actions(screen, "passed")
+                    else:
+                        error_opts = ERROR_TEMPLATES[result]
+                        error_msg, classification, classification_reason = random.choice(error_opts)
+                        last_actions = generate_last_actions(screen, "failed")
+
+                    # Determine action_type from last actions
+                    action_type = "other"
+                    for action in reversed(last_actions):
+                        al = action.lower()
+                        if "fill" in al: action_type = "fill"; break
+                        if "tap" in al or "click" in al: action_type = "tap"; break
+                        if "swipe" in al or "scroll" in al: action_type = "swipe"; break
+                        if "scrollintoview" in al: action_type = "scrollIntoView"; break
+                        if "press" in al: action_type = "press"; break
+
+                    cursor.execute(
+                        """INSERT INTO test_runs
+                           (test_file, test_name, platform, device_id, duration_ms, result,
+                            error_message, last_actions, classification, classification_reason,
+                            screen_name, action_type, session_id, run_at)
+                           VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+                        (
+                            test_file, test_name, platform, device_id,
+                            duration_ms, result, error_msg,
+                            json.dumps(last_actions), classification,
+                            classification_reason, screen, action_type,
+                            f"{device_id}_{day}",
+                            generate_run_at(base_date, day),
+                        ),
+                    )
+                    total += 1
+
+    db.commit()
+    db.close()
+    print(f"Seeded {total} test runs ({passed} passed, {failed} failed)")
+    print(f"Overall pass rate: {passed/total*100:.1f}%")
+
+
+if __name__ == "__main__":
+    path = sys.argv[1] if len(sys.argv) > 1 else DB_PATH
+    seed_database(path)