@trieungoctam/vibekit 1.0.0

package/skills/dev/databases/scripts/db_performance_check.py

@@ -0,0 +1,457 @@
+#!/usr/bin/env python3
+"""
+Database performance analysis tool for MongoDB and PostgreSQL.
+Analyzes slow queries, recommends indexes, and generates reports.
+"""
+
+import argparse
+import json
+import sys
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+
+# Windows UTF-8 compatibility (works for both local and global installs)
+CLAUDE_ROOT = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(CLAUDE_ROOT / 'scripts'))
+try:
+    from win_compat import ensure_utf8_stdout
+    ensure_utf8_stdout()
+except ImportError:
+    if sys.platform == 'win32':
+        import io
+        if hasattr(sys.stdout, 'buffer'):
+            sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+
+try:
+    from pymongo import MongoClient
+    MONGO_AVAILABLE = True
+except ImportError:
+    MONGO_AVAILABLE = False
+
+try:
+    import psycopg2
+    from psycopg2.extras import RealDictCursor
+    POSTGRES_AVAILABLE = True
+except ImportError:
+    POSTGRES_AVAILABLE = False
+
+
+@dataclass
+class SlowQuery:
+    """Represents a slow query."""
+
+    query: str
+    execution_time_ms: float
+    count: int
+    collection_or_table: Optional[str] = None
+    index_used: Optional[str] = None
+
+
+@dataclass
+class IndexRecommendation:
+    """Index recommendation."""
+
+    collection_or_table: str
+    fields: List[str]
+    reason: str
+    estimated_benefit: str
+
+
+@dataclass
+class PerformanceReport:
+    """Performance analysis report."""
+
+    database_type: str
+    database_name: str
+    timestamp: datetime
+    slow_queries: List[SlowQuery]
+    index_recommendations: List[IndexRecommendation]
+    database_metrics: Dict[str, any]
+
+
+class PerformanceAnalyzer:
+    """Analyzes database performance."""
+
+    def __init__(self, db_type: str, connection_string: str, threshold_ms: int = 100):
+        """
+        Initialize performance analyzer.
+
+        Args:
+            db_type: Database type ('mongodb' or 'postgres')
+            connection_string: Database connection string
+            threshold_ms: Slow query threshold in milliseconds
+        """
+        self.db_type = db_type.lower()
+        self.connection_string = connection_string
+        self.threshold_ms = threshold_ms
+
+        self.client = None
+        self.db = None
+        self.conn = None
+
+    def connect(self) -> bool:
+        """Connect to database."""
+        try:
+            if self.db_type == "mongodb":
+                if not MONGO_AVAILABLE:
+                    print("Error: pymongo not installed")
+                    return False
+                self.client = MongoClient(self.connection_string)
+                self.db = self.client.get_default_database()
+                self.client.server_info()
+                return True
+
+            elif self.db_type == "postgres":
+                if not POSTGRES_AVAILABLE:
+                    print("Error: psycopg2 not installed")
+                    return False
+                self.conn = psycopg2.connect(self.connection_string)
+                return True
+
+            else:
+                print(f"Error: Unsupported database type: {self.db_type}")
+                return False
+
+        except Exception as e:
+            print(f"Connection error: {e}")
+            return False
+
+    def disconnect(self):
+        """Disconnect from database."""
+        try:
+            if self.client:
+                self.client.close()
+            if self.conn:
+                self.conn.close()
+        except Exception as e:
+            print(f"Disconnect error: {e}")
+
+    def analyze(self) -> Optional[PerformanceReport]:
+        """
+        Analyze database performance.
+
+        Returns:
+            PerformanceReport if successful, None otherwise
+        """
+        try:
+            if self.db_type == "mongodb":
+                return self._analyze_mongodb()
+            elif self.db_type == "postgres":
+                return self._analyze_postgres()
+            else:
+                return None
+
+        except Exception as e:
+            print(f"Analysis error: {e}")
+            return None
+
+    def _analyze_mongodb(self) -> PerformanceReport:
+        """Analyze MongoDB performance."""
+        slow_queries = []
+        index_recommendations = []
+
+        # Enable profiling if not enabled
+        profiling_level = self.db.command("profile", -1)
+        if profiling_level.get("was", 0) == 0:
+            self.db.command("profile", 1, slowms=self.threshold_ms)
+
+        # Get slow queries from system.profile
+        for doc in self.db.system.profile.find(
+            {"millis": {"$gte": self.threshold_ms}},
+            limit=50
+        ).sort("millis", -1):
+
+            query_str = json.dumps(doc.get("command", {}), default=str)
+
+            slow_queries.append(SlowQuery(
+                query=query_str,
+                execution_time_ms=doc.get("millis", 0),
+                count=1,
+                collection_or_table=doc.get("ns", "").split(".")[-1] if "ns" in doc else None,
+                index_used=doc.get("planSummary")
+            ))
+
+        # Analyze collections for index recommendations
+        for coll_name in self.db.list_collection_names():
+            if coll_name.startswith("system."):
+                continue
+
+            coll = self.db[coll_name]
+
+            # Check for collections scans
+            stats = coll.aggregate([
+                {"$collStats": {"storageStats": {}}}
+            ]).next()
+
+            # Check if collection has indexes
+            indexes = list(coll.list_indexes())
+
+            if len(indexes) <= 1:  # Only _id index
+                # Recommend indexes based on common patterns
+                # Sample documents to find frequently queried fields
+                sample = list(coll.find().limit(100))
+
+                if sample:
+                    # Find fields that appear in most documents
+                    field_freq = {}
+                    for doc in sample:
+                        for field in doc.keys():
+                            if field != "_id":
+                                field_freq[field] = field_freq.get(field, 0) + 1
+
+                    # Recommend index on most common field
+                    if field_freq:
+                        top_field = max(field_freq.items(), key=lambda x: x[1])[0]
+                        index_recommendations.append(IndexRecommendation(
+                            collection_or_table=coll_name,
+                            fields=[top_field],
+                            reason="Frequently queried field without index",
+                            estimated_benefit="High"
+                        ))
+
+        # Get database metrics
+        server_status = self.client.admin.command("serverStatus")
+        db_stats = self.db.command("dbStats")
+
+        metrics = {
+            "connections": server_status.get("connections", {}).get("current", 0),
+            "operations_per_sec": server_status.get("opcounters", {}).get("query", 0),
+            "database_size_mb": db_stats.get("dataSize", 0) / (1024 * 1024),
+            "index_size_mb": db_stats.get("indexSize", 0) / (1024 * 1024),
+            "collections": db_stats.get("collections", 0)
+        }
+
+        return PerformanceReport(
+            database_type="mongodb",
+            database_name=self.db.name,
+            timestamp=datetime.now(),
+            slow_queries=slow_queries[:10],  # Top 10
+            index_recommendations=index_recommendations,
+            database_metrics=metrics
+        )
+
+    def _analyze_postgres(self) -> PerformanceReport:
+        """Analyze PostgreSQL performance."""
+        slow_queries = []
+        index_recommendations = []
+
+        with self.conn.cursor(cursor_factory=RealDictCursor) as cur:
+            # Check if pg_stat_statements extension is available
+            cur.execute("""
+                SELECT EXISTS (
+                    SELECT 1 FROM pg_extension WHERE extname = 'pg_stat_statements'
+                ) AS has_extension
+            """)
+            has_pg_stat_statements = cur.fetchone()["has_extension"]
+
+            if has_pg_stat_statements:
+                # Get slow queries from pg_stat_statements
+                cur.execute("""
+                    SELECT
+                        query,
+                        mean_exec_time,
+                        calls,
+                        total_exec_time
+                    FROM pg_stat_statements
+                    WHERE mean_exec_time >= %s
+                    ORDER BY mean_exec_time DESC
+                    LIMIT 10
+                """, (self.threshold_ms,))
+
+                for row in cur.fetchall():
+                    slow_queries.append(SlowQuery(
+                        query=row["query"],
+                        execution_time_ms=row["mean_exec_time"],
+                        count=row["calls"]
+                    ))
+
+            # Find tables with sequential scans (potential index candidates)
+            cur.execute("""
+                SELECT
+                    schemaname,
+                    tablename,
+                    seq_scan,
+                    seq_tup_read,
+                    idx_scan
+                FROM pg_stat_user_tables
+                WHERE seq_scan > 1000
+                    AND (idx_scan IS NULL OR seq_scan > idx_scan * 2)
+                ORDER BY seq_tup_read DESC
+                LIMIT 10
+            """)
+
+            for row in cur.fetchall():
+                index_recommendations.append(IndexRecommendation(
+                    collection_or_table=f"{row['schemaname']}.{row['tablename']}",
+                    fields=["<analyze query patterns>"],
+                    reason=f"High sequential scans ({row['seq_scan']}) vs index scans ({row['idx_scan'] or 0})",
+                    estimated_benefit="High" if row["seq_tup_read"] > 100000 else "Medium"
+                ))
+
+            # Find unused indexes
+            cur.execute("""
+                SELECT
+                    schemaname,
+                    tablename,
+                    indexname,
+                    idx_scan
+                FROM pg_stat_user_indexes
+                WHERE idx_scan = 0
+                    AND indexname NOT LIKE '%_pkey'
+                ORDER BY pg_relation_size(indexrelid) DESC
+            """)
+
+            unused_indexes = []
+            for row in cur.fetchall():
+                unused_indexes.append(
+                    f"{row['schemaname']}.{row['tablename']}.{row['indexname']}"
+                )
+
+            # Database metrics
+            cur.execute("""
+                SELECT
+                    sum(numbackends) AS connections,
+                    sum(xact_commit) AS commits,
+                    sum(xact_rollback) AS rollbacks
+                FROM pg_stat_database
+                WHERE datname = current_database()
+            """)
+            stats = cur.fetchone()
+
+            cur.execute("""
+                SELECT pg_database_size(current_database()) AS db_size
+            """)
+            db_size = cur.fetchone()["db_size"]
+
+            cur.execute("""
+                SELECT
+                    sum(heap_blks_hit) / NULLIF(sum(heap_blks_hit) + sum(heap_blks_read), 0) AS cache_hit_ratio
+                FROM pg_statio_user_tables
+            """)
+            cache_ratio = cur.fetchone()["cache_hit_ratio"] or 0
+
+            metrics = {
+                "connections": stats["connections"],
+                "commits": stats["commits"],
+                "rollbacks": stats["rollbacks"],
+                "database_size_mb": db_size / (1024 * 1024),
+                "cache_hit_ratio": float(cache_ratio),
+                "unused_indexes": unused_indexes
+            }
+
+        return PerformanceReport(
+            database_type="postgres",
+            database_name=self.conn.info.dbname,
+            timestamp=datetime.now(),
+            slow_queries=slow_queries,
+            index_recommendations=index_recommendations,
+            database_metrics=metrics
+        )
+
+    def print_report(self, report: PerformanceReport):
+        """Print performance report."""
+        print("=" * 80)
+        print(f"Database Performance Report - {report.database_type.upper()}")
+        print(f"Database: {report.database_name}")
+        print(f"Timestamp: {report.timestamp}")
+        print("=" * 80)
+
+        print("\n## Database Metrics")
+        print("-" * 80)
+        for key, value in report.database_metrics.items():
+            if isinstance(value, float):
+                print(f"{key}: {value:.2f}")
+            else:
+                print(f"{key}: {value}")
+
+        print("\n## Slow Queries")
+        print("-" * 80)
+        if report.slow_queries:
+            for i, query in enumerate(report.slow_queries, 1):
+                print(f"\n{i}. Execution Time: {query.execution_time_ms:.2f}ms | Count: {query.count}")
+                if query.collection_or_table:
+                    print(f"   Collection/Table: {query.collection_or_table}")
+                if query.index_used:
+                    print(f"   Index Used: {query.index_used}")
+                print(f"   Query: {query.query[:200]}...")
+        else:
+            print("No slow queries found")
+
+        print("\n## Index Recommendations")
+        print("-" * 80)
+        if report.index_recommendations:
+            for i, rec in enumerate(report.index_recommendations, 1):
+                print(f"\n{i}. {rec.collection_or_table}")
+                print(f"   Fields: {', '.join(rec.fields)}")
+                print(f"   Reason: {rec.reason}")
+                print(f"   Estimated Benefit: {rec.estimated_benefit}")
+
+                if report.database_type == "mongodb":
+                    index_spec = {field: 1 for field in rec.fields}
+                    print(f"   Command: db.{rec.collection_or_table}.createIndex({json.dumps(index_spec)})")
+                elif report.database_type == "postgres":
+                    fields_str = ", ".join(rec.fields)
+                    print(f"   Command: CREATE INDEX idx_{rec.collection_or_table.replace('.', '_')}_{rec.fields[0]} ON {rec.collection_or_table}({fields_str});")
+        else:
+            print("No index recommendations")
+
+        print("\n" + "=" * 80)
+
+    def save_report(self, report: PerformanceReport, filename: str):
+        """Save report to JSON file."""
+        # Convert dataclasses to dict
+        report_dict = {
+            "database_type": report.database_type,
+            "database_name": report.database_name,
+            "timestamp": report.timestamp.isoformat(),
+            "slow_queries": [asdict(q) for q in report.slow_queries],
+            "index_recommendations": [asdict(r) for r in report.index_recommendations],
+            "database_metrics": report.database_metrics
+        }
+
+        with open(filename, "w") as f:
+            json.dump(report_dict, f, indent=2, default=str)
+
+        print(f"\nReport saved to: {filename}")
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Database performance analysis tool")
+    parser.add_argument("--db", required=True, choices=["mongodb", "postgres"],
+                       help="Database type")
+    parser.add_argument("--uri", required=True, help="Database connection string")
+    parser.add_argument("--threshold", type=int, default=100,
+                       help="Slow query threshold in milliseconds (default: 100)")
+    parser.add_argument("--output", help="Save report to JSON file")
+
+    args = parser.parse_args()
+
+    analyzer = PerformanceAnalyzer(args.db, args.uri, args.threshold)
+
+    if not analyzer.connect():
+        sys.exit(1)
+
+    try:
+        print(f"Analyzing {args.db} performance (threshold: {args.threshold}ms)...")
+        report = analyzer.analyze()
+
+        if report:
+            analyzer.print_report(report)
+
+            if args.output:
+                analyzer.save_report(report, args.output)
+
+            sys.exit(0)
+        else:
+            print("Analysis failed")
+            sys.exit(1)
+
+    finally:
+        analyzer.disconnect()
+
+
+if __name__ == "__main__":
+    main()

package/skills/dev/databases/scripts/requirements.txt

@@ -0,0 +1,20 @@
+# Databases Skill Dependencies
+# Python 3.10+ required
+
+# No Python package dependencies - uses only standard library
+
+# Testing dependencies (dev)
+pytest>=8.0.0
+pytest-cov>=4.1.0
+pytest-mock>=3.12.0
+
+# Note: This skill requires database CLI tools:
+#
+# PostgreSQL:
+#   - psql CLI (comes with PostgreSQL)
+#   - Ubuntu/Debian: sudo apt-get install postgresql-client
+#   - macOS: brew install postgresql
+#
+# MongoDB:
+#   - mongosh CLI: https://www.mongodb.com/try/download/shell
+#   - mongodump/mongorestore: https://www.mongodb.com/try/download/database-tools

package/skills/dev/databases/scripts/tests/coverage-db.json

@@ -0,0 +1 @@
+{"meta": {"format": 3, "version": "7.11.0", "timestamp": "2025-11-05T00:57:30.958744", "branch_coverage": false, "show_contexts": false}, "files": {"db_backup.py": {"executed_lines": [2, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 20, 21, 22, 24, 25, 26, 27, 28, 29, 30, 33, 34, 36, 44, 45, 46, 48, 67, 68, 70, 71, 72, 73, 78, 87, 88, 89, 91, 92, 94, 95, 97, 98, 100, 105, 106, 107, 108, 109, 110, 111, 113, 115, 124, 127, 128, 130, 136, 145, 146, 147, 149, 150, 151, 153, 154, 156, 172, 173, 175, 179, 198, 199, 200, 202, 214, 216, 217, 218, 221, 222, 228, 229, 230, 232, 234, 235, 236, 237, 238, 247, 249, 251, 252, 258, 260, 263, 266, 270, 271, 277, 279, 280, 291, 292, 293, 300, 304, 305, 311, 318, 320, 321, 322, 323, 325, 334, 338, 340, 351, 352, 354, 355, 358, 359, 360, 362, 363, 365, 366, 368, 370, 372, 382, 384, 388, 389, 392, 394, 396, 397, 398, 399, 400, 401, 402, 403, 404, 406, 408, 409, 410, 411, 414, 416, 418, 428, 429, 432, 501], "summary": {"covered_lines": 153, "num_statements": 249, "percent_covered": 61.44578313253012, "percent_covered_display": "61", "missing_lines": 96, "excluded_lines": 0}, "missing_lines": [75, 76, 101, 102, 125, 132, 133, 134, 158, 159, 160, 165, 166, 168, 169, 170, 176, 177, 181, 190, 191, 193, 194, 196, 223, 224, 225, 226, 240, 241, 243, 244, 245, 253, 254, 255, 256, 264, 267, 268, 273, 274, 275, 282, 283, 284, 301, 302, 307, 308, 309, 335, 336, 356, 367, 385, 412, 434, 435, 437, 440, 443, 444, 445, 446, 448, 452, 453, 454, 455, 459, 462, 463, 465, 468, 470, 472, 473, 479, 481, 482, 483, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 496, 497, 498, 502], "excluded_lines": [], "functions": {"BackupManager.__init__": {"executed_lines": [44, 45, 46], "summary": {"covered_lines": 3, "num_statements": 3, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "BackupManager.create_backup": {"executed_lines": [67, 68, 70, 71, 72, 73], "summary": {"covered_lines": 6, "num_statements": 8, "percent_covered": 75.0, "percent_covered_display": "75", "missing_lines": 2, "excluded_lines": 0}, "missing_lines": [75, 76], "excluded_lines": []}, "BackupManager._backup_mongodb": {"executed_lines": [87, 88, 89, 91, 92, 94, 95, 97, 98, 100, 105, 106, 107, 108, 109, 110, 111, 113, 115, 124, 127, 128, 130], "summary": {"covered_lines": 23, "num_statements": 29, "percent_covered": 79.3103448275862, "percent_covered_display": "79", "missing_lines": 6, "excluded_lines": 0}, "missing_lines": [101, 102, 125, 132, 133, 134], "excluded_lines": []}, "BackupManager._backup_postgres": {"executed_lines": [145, 146, 147, 149, 150, 151, 153, 154, 156, 172, 173, 175, 179, 198, 199, 200], "summary": {"covered_lines": 16, "num_statements": 32, "percent_covered": 50.0, "percent_covered_display": "50", "missing_lines": 16, "excluded_lines": 0}, "missing_lines": [158, 159, 160, 165, 166, 168, 169, 170, 176, 177, 181, 190, 191, 193, 194, 196], "excluded_lines": []}, "BackupManager.restore_backup": {"executed_lines": [214, 216, 217, 218, 221, 222, 228, 229, 230, 232, 234, 235, 236, 237, 238], "summary": {"covered_lines": 15, "num_statements": 24, "percent_covered": 62.5, "percent_covered_display": "62", "missing_lines": 9, "excluded_lines": 0}, "missing_lines": [223, 224, 225, 226, 240, 241, 243, 244, 245], "excluded_lines": []}, "BackupManager._restore_mongodb": {"executed_lines": [249, 251, 252, 258, 260, 263, 266, 270, 271], "summary": {"covered_lines": 9, "num_statements": 19, "percent_covered": 47.36842105263158, "percent_covered_display": "47", "missing_lines": 10, "excluded_lines": 0}, "missing_lines": [253, 254, 255, 256, 264, 267, 268, 273, 274, 275], "excluded_lines": []}, "BackupManager._restore_postgres": {"executed_lines": [279, 280, 291, 292, 293, 300, 304, 305], "summary": {"covered_lines": 8, "num_statements": 16, "percent_covered": 50.0, "percent_covered_display": "50", "missing_lines": 8, "excluded_lines": 0}, "missing_lines": [282, 283, 284, 301, 302, 307, 308, 309], "excluded_lines": []}, "BackupManager.list_backups": {"executed_lines": [318, 320, 321, 322, 323, 325, 334, 338], "summary": {"covered_lines": 8, "num_statements": 10, "percent_covered": 80.0, "percent_covered_display": "80", "missing_lines": 2, "excluded_lines": 0}, "missing_lines": [335, 336], "excluded_lines": []}, "BackupManager.cleanup_old_backups": {"executed_lines": [351, 352, 354, 355, 358, 359, 360, 362, 363, 365, 366, 368, 370], "summary": {"covered_lines": 13, "num_statements": 15, "percent_covered": 86.66666666666667, "percent_covered_display": "87", "missing_lines": 2, "excluded_lines": 0}, "missing_lines": [356, 367], "excluded_lines": []}, "BackupManager._verify_backup": {"executed_lines": [382, 384, 388, 389, 392], "summary": {"covered_lines": 5, "num_statements": 6, "percent_covered": 83.33333333333333, "percent_covered_display": "83", "missing_lines": 1, "excluded_lines": 0}, "missing_lines": [385], "excluded_lines": []}, "BackupManager._get_size": {"executed_lines": [396, 397, 398, 399, 400, 401, 402, 403, 404], "summary": {"covered_lines": 9, "num_statements": 9, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "BackupManager._format_size": {"executed_lines": [408, 409, 410, 411], "summary": {"covered_lines": 4, "num_statements": 5, "percent_covered": 80.0, "percent_covered_display": "80", "missing_lines": 1, "excluded_lines": 0}, "missing_lines": [412], "excluded_lines": []}, "BackupManager._save_metadata": {"executed_lines": [416, 418, 428, 429], "summary": {"covered_lines": 4, "num_statements": 4, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "main": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 38, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 38, "excluded_lines": 0}, "missing_lines": [434, 435, 437, 440, 443, 444, 445, 446, 448, 452, 453, 454, 455, 459, 462, 463, 465, 468, 470, 472, 473, 479, 481, 482, 483, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 496, 497, 498], "excluded_lines": []}, "": {"executed_lines": [2, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 20, 21, 22, 24, 25, 26, 27, 28, 29, 30, 33, 34, 36, 48, 78, 136, 202, 247, 277, 311, 340, 372, 394, 406, 414, 432, 501], "summary": {"covered_lines": 30, "num_statements": 31, "percent_covered": 96.7741935483871, "percent_covered_display": "97", "missing_lines": 1, "excluded_lines": 0}, "missing_lines": [502], "excluded_lines": []}}, "classes": {"BackupInfo": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 0, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "BackupManager": {"executed_lines": [44, 45, 46, 67, 68, 70, 71, 72, 73, 87, 88, 89, 91, 92, 94, 95, 97, 98, 100, 105, 106, 107, 108, 109, 110, 111, 113, 115, 124, 127, 128, 130, 145, 146, 147, 149, 150, 151, 153, 154, 156, 172, 173, 175, 179, 198, 199, 200, 214, 216, 217, 218, 221, 222, 228, 229, 230, 232, 234, 235, 236, 237, 238, 249, 251, 252, 258, 260, 263, 266, 270, 271, 279, 280, 291, 292, 293, 300, 304, 305, 318, 320, 321, 322, 323, 325, 334, 338, 351, 352, 354, 355, 358, 359, 360, 362, 363, 365, 366, 368, 370, 382, 384, 388, 389, 392, 396, 397, 398, 399, 400, 401, 402, 403, 404, 408, 409, 410, 411, 416, 418, 428, 429], "summary": {"covered_lines": 123, "num_statements": 180, "percent_covered": 68.33333333333333, "percent_covered_display": "68", "missing_lines": 57, "excluded_lines": 0}, "missing_lines": [75, 76, 101, 102, 125, 132, 133, 134, 158, 159, 160, 165, 166, 168, 169, 170, 176, 177, 181, 190, 191, 193, 194, 196, 223, 224, 225, 226, 240, 241, 243, 244, 245, 253, 254, 255, 256, 264, 267, 268, 273, 274, 275, 282, 283, 284, 301, 302, 307, 308, 309, 335, 336, 356, 367, 385, 412], "excluded_lines": []}, "": {"executed_lines": [2, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 20, 21, 22, 24, 25, 26, 27, 28, 29, 30, 33, 34, 36, 48, 78, 136, 202, 247, 277, 311, 340, 372, 394, 406, 414, 432, 501], "summary": {"covered_lines": 30, "num_statements": 69, "percent_covered": 43.47826086956522, "percent_covered_display": "43", "missing_lines": 39, "excluded_lines": 0}, "missing_lines": [434, 435, 437, 440, 443, 444, 445, 446, 448, 452, 453, 454, 455, 459, 462, 463, 465, 468, 470, 472, 473, 479, 481, 482, 483, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 496, 497, 498, 502], "excluded_lines": []}}}, "db_migrate.py": {"executed_lines": [2, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 20, 22, 23, 26, 27, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 44, 45, 47, 56, 57, 58, 59, 61, 62, 63, 65, 72, 73, 83, 91, 92, 98, 108, 124, 135, 136, 137, 138, 140, 147, 148, 156, 157, 158, 160, 170, 171, 172, 173, 175, 176, 177, 178, 179, 184, 192, 194, 195, 196, 207, 208, 209, 210, 211, 213, 214, 223, 227, 229, 240, 242, 243, 244, 245, 249, 287, 299, 300, 304, 305, 306, 338, 413], "summary": {"covered_lines": 89, "num_statements": 221, "percent_covered": 40.27149321266968, "percent_covered_display": "40", "missing_lines": 132, "excluded_lines": 0}, "missing_lines": [18, 24, 25, 74, 75, 76, 77, 78, 80, 81, 84, 85, 86, 87, 88, 94, 95, 96, 100, 101, 102, 103, 104, 105, 106, 110, 112, 113, 114, 115, 122, 180, 181, 182, 199, 200, 201, 202, 203, 204, 224, 225, 246, 247, 248, 251, 252, 253, 254, 255, 261, 267, 268, 269, 272, 276, 278, 279, 281, 282, 283, 284, 285, 301, 302, 308, 309, 310, 312, 314, 315, 316, 317, 318, 320, 321, 322, 323, 324, 325, 326, 328, 329, 331, 332, 333, 334, 335, 340, 341, 343, 344, 347, 350, 351, 352, 356, 357, 361, 362, 363, 367, 369, 372, 373, 374, 375, 378, 379, 380, 382, 384, 385, 387, 388, 390, 391, 392, 393, 394, 396, 397, 398, 399, 401, 402, 403, 405, 406, 407, 410, 414], "excluded_lines": [], "functions": {"MigrationManager.__init__": {"executed_lines": [56, 57, 58, 59, 61, 62, 63], "summary": {"covered_lines": 7, "num_statements": 7, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "MigrationManager.connect": {"executed_lines": [72, 73, 83, 91, 92], "summary": {"covered_lines": 5, "num_statements": 20, "percent_covered": 25.0, "percent_covered_display": "25", "missing_lines": 15, "excluded_lines": 0}, "missing_lines": [74, 75, 76, 77, 78, 80, 81, 84, 85, 86, 87, 88, 94, 95, 96], "excluded_lines": []}, "MigrationManager.disconnect": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 7, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 7, "excluded_lines": 0}, "missing_lines": [100, 101, 102, 103, 104, 105, 106], "excluded_lines": []}, "MigrationManager._ensure_migrations_table": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 6, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 6, "excluded_lines": 0}, "missing_lines": [110, 112, 113, 114, 115, 122], "excluded_lines": []}, "MigrationManager.generate_migration": {"executed_lines": [135, 136, 137, 138, 140, 147, 148, 156, 157, 158, 160, 170, 171, 172, 173, 175, 176, 177, 178, 179], "summary": {"covered_lines": 20, "num_statements": 23, "percent_covered": 86.95652173913044, "percent_covered_display": "87", "missing_lines": 3, "excluded_lines": 0}, "missing_lines": [180, 181, 182], "excluded_lines": []}, "MigrationManager.get_pending_migrations": {"executed_lines": [192, 194, 195, 196, 207, 208, 209, 210, 211, 213, 214, 223, 227], "summary": {"covered_lines": 13, "num_statements": 21, "percent_covered": 61.904761904761905, "percent_covered_display": "62", "missing_lines": 8, "excluded_lines": 0}, "missing_lines": [199, 200, 201, 202, 203, 204, 224, 225], "excluded_lines": []}, "MigrationManager.apply_migration": {"executed_lines": [240, 242, 243, 244, 245, 249], "summary": {"covered_lines": 6, "num_statements": 27, "percent_covered": 22.22222222222222, "percent_covered_display": "22", "missing_lines": 21, "excluded_lines": 0}, "missing_lines": [246, 247, 248, 251, 252, 253, 254, 255, 261, 267, 268, 269, 272, 276, 278, 279, 281, 282, 283, 284, 285], "excluded_lines": []}, "MigrationManager.rollback_migration": {"executed_lines": [299, 300, 304, 305, 306], "summary": {"covered_lines": 5, "num_statements": 30, "percent_covered": 16.666666666666668, "percent_covered_display": "17", "missing_lines": 25, "excluded_lines": 0}, "missing_lines": [301, 302, 308, 309, 310, 312, 314, 315, 316, 317, 318, 320, 321, 322, 323, 324, 325, 326, 328, 329, 331, 332, 333, 334, 335], "excluded_lines": []}, "main": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 43, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 43, "excluded_lines": 0}, "missing_lines": [340, 341, 343, 344, 347, 350, 351, 352, 356, 357, 361, 362, 363, 367, 369, 372, 373, 374, 375, 378, 379, 380, 382, 384, 385, 387, 388, 390, 391, 392, 393, 394, 396, 397, 398, 399, 401, 402, 403, 405, 406, 407, 410], "excluded_lines": []}, "": {"executed_lines": [2, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 20, 22, 23, 26, 27, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 44, 45, 47, 65, 98, 108, 124, 184, 229, 287, 338, 413], "summary": {"covered_lines": 33, "num_statements": 37, "percent_covered": 89.1891891891892, "percent_covered_display": "89", "missing_lines": 4, "excluded_lines": 0}, "missing_lines": [18, 24, 25, 414], "excluded_lines": []}}, "classes": {"Migration": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 0, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "MigrationManager": {"executed_lines": [56, 57, 58, 59, 61, 62, 63, 72, 73, 83, 91, 92, 135, 136, 137, 138, 140, 147, 148, 156, 157, 158, 160, 170, 171, 172, 173, 175, 176, 177, 178, 179, 192, 194, 195, 196, 207, 208, 209, 210, 211, 213, 214, 223, 227, 240, 242, 243, 244, 245, 249, 299, 300, 304, 305, 306], "summary": {"covered_lines": 56, "num_statements": 141, "percent_covered": 39.716312056737586, "percent_covered_display": "40", "missing_lines": 85, "excluded_lines": 0}, "missing_lines": [74, 75, 76, 77, 78, 80, 81, 84, 85, 86, 87, 88, 94, 95, 96, 100, 101, 102, 103, 104, 105, 106, 110, 112, 113, 114, 115, 122, 180, 181, 182, 199, 200, 201, 202, 203, 204, 224, 225, 246, 247, 248, 251, 252, 253, 254, 255, 261, 267, 268, 269, 272, 276, 278, 279, 281, 282, 283, 284, 285, 301, 302, 308, 309, 310, 312, 314, 315, 316, 317, 318, 320, 321, 322, 323, 324, 325, 326, 328, 329, 331, 332, 333, 334, 335], "excluded_lines": []}, "": {"executed_lines": [2, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 20, 22, 23, 26, 27, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 44, 45, 47, 65, 98, 108, 124, 184, 229, 287, 338, 413], "summary": {"covered_lines": 33, "num_statements": 80, "percent_covered": 41.25, "percent_covered_display": "41", "missing_lines": 47, "excluded_lines": 0}, "missing_lines": [18, 24, 25, 340, 341, 343, 344, 347, 350, 351, 352, 356, 357, 361, 362, 363, 367, 369, 372, 373, 374, 375, 378, 379, 380, 382, 384, 385, 387, 388, 390, 391, 392, 393, 394, 396, 397, 398, 399, 401, 402, 403, 405, 406, 407, 410, 414], "excluded_lines": []}}}, "db_performance_check.py": {"executed_lines": [2, 7, 8, 9, 10, 11, 12, 14, 15, 17, 18, 20, 21, 24, 25, 28, 29, 30, 32, 33, 34, 35, 36, 39, 40, 41, 43, 44, 45, 46, 49, 50, 51, 53, 54, 55, 56, 57, 58, 61, 62, 64, 73, 74, 75, 77, 78, 79, 81, 83, 84, 93, 101, 102, 108, 110, 111, 112, 113, 114, 118, 137, 222, 340, 342, 343, 344, 345, 346, 348, 349, 350, 351, 352, 354, 356, 357, 358, 359, 360, 361, 362, 363, 365, 369, 370, 371, 372, 373, 374, 375, 376, 378, 379, 380, 387, 389, 392, 401, 402, 404, 407, 443], "summary": {"covered_lines": 85, "num_statements": 194, "percent_covered": 43.81443298969072, "percent_covered_display": "44", "missing_lines": 109, "excluded_lines": 0}, "missing_lines": [16, 22, 23, 85, 86, 87, 88, 89, 90, 91, 94, 95, 96, 97, 98, 104, 105, 106, 115, 116, 125, 126, 127, 128, 129, 131, 133, 134, 135, 139, 140, 143, 144, 145, 148, 153, 155, 164, 165, 166, 168, 171, 176, 178, 181, 183, 185, 186, 187, 188, 189, 192, 193, 194, 202, 203, 205, 213, 224, 225, 227, 229, 234, 236, 238, 250, 251, 258, 272, 273, 281, 293, 294, 295, 300, 308, 310, 313, 315, 320, 322, 331, 364, 367, 381, 382, 383, 385, 409, 410, 412, 413, 415, 417, 419, 421, 422, 424, 425, 426, 428, 429, 431, 432, 434, 436, 437, 440, 444], "excluded_lines": [], "functions": {"PerformanceAnalyzer.__init__": {"executed_lines": [73, 74, 75, 77, 78, 79], "summary": {"covered_lines": 6, "num_statements": 6, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "PerformanceAnalyzer.connect": {"executed_lines": [83, 84, 93, 101, 102], "summary": {"covered_lines": 5, "num_statements": 20, "percent_covered": 25.0, "percent_covered_display": "25", "missing_lines": 15, "excluded_lines": 0}, "missing_lines": [85, 86, 87, 88, 89, 90, 91, 94, 95, 96, 97, 98, 104, 105, 106], "excluded_lines": []}, "PerformanceAnalyzer.disconnect": {"executed_lines": [110, 111, 112, 113, 114], "summary": {"covered_lines": 5, "num_statements": 7, "percent_covered": 71.42857142857143, "percent_covered_display": "71", "missing_lines": 2, "excluded_lines": 0}, "missing_lines": [115, 116], "excluded_lines": []}, "PerformanceAnalyzer.analyze": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 9, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 9, "excluded_lines": 0}, "missing_lines": [125, 126, 127, 128, 129, 131, 133, 134, 135], "excluded_lines": []}, "PerformanceAnalyzer._analyze_mongodb": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 29, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 29, "excluded_lines": 0}, "missing_lines": [139, 140, 143, 144, 145, 148, 153, 155, 164, 165, 166, 168, 171, 176, 178, 181, 183, 185, 186, 187, 188, 189, 192, 193, 194, 202, 203, 205, 213], "excluded_lines": []}, "PerformanceAnalyzer._analyze_postgres": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 24, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 24, "excluded_lines": 0}, "missing_lines": [224, 225, 227, 229, 234, 236, 238, 250, 251, 258, 272, 273, 281, 293, 294, 295, 300, 308, 310, 313, 315, 320, 322, 331], "excluded_lines": []}, "PerformanceAnalyzer.print_report": {"executed_lines": [342, 343, 344, 345, 346, 348, 349, 350, 351, 352, 354, 356, 357, 358, 359, 360, 361, 362, 363, 365, 369, 370, 371, 372, 373, 374, 375, 376, 378, 379, 380, 387], "summary": {"covered_lines": 32, "num_statements": 38, "percent_covered": 84.21052631578948, "percent_covered_display": "84", "missing_lines": 6, "excluded_lines": 0}, "missing_lines": [364, 367, 381, 382, 383, 385], "excluded_lines": []}, "PerformanceAnalyzer.save_report": {"executed_lines": [392, 401, 402, 404], "summary": {"covered_lines": 4, "num_statements": 4, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "main": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 20, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 20, "excluded_lines": 0}, "missing_lines": [409, 410, 412, 413, 415, 417, 419, 421, 422, 424, 425, 426, 428, 429, 431, 432, 434, 436, 437, 440], "excluded_lines": []}, "": {"executed_lines": [2, 7, 8, 9, 10, 11, 12, 14, 15, 17, 18, 20, 21, 24, 25, 28, 29, 30, 32, 33, 34, 35, 36, 39, 40, 41, 43, 44, 45, 46, 49, 50, 51, 53, 54, 55, 56, 57, 58, 61, 62, 64, 81, 108, 118, 137, 222, 340, 389, 407, 443], "summary": {"covered_lines": 33, "num_statements": 37, "percent_covered": 89.1891891891892, "percent_covered_display": "89", "missing_lines": 4, "excluded_lines": 0}, "missing_lines": [16, 22, 23, 444], "excluded_lines": []}}, "classes": {"SlowQuery": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 0, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "IndexRecommendation": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 0, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "PerformanceReport": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 0, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "PerformanceAnalyzer": {"executed_lines": [73, 74, 75, 77, 78, 79, 83, 84, 93, 101, 102, 110, 111, 112, 113, 114, 342, 343, 344, 345, 346, 348, 349, 350, 351, 352, 354, 356, 357, 358, 359, 360, 361, 362, 363, 365, 369, 370, 371, 372, 373, 374, 375, 376, 378, 379, 380, 387, 392, 401, 402, 404], "summary": {"covered_lines": 52, "num_statements": 137, "percent_covered": 37.956204379562045, "percent_covered_display": "38", "missing_lines": 85, "excluded_lines": 0}, "missing_lines": [85, 86, 87, 88, 89, 90, 91, 94, 95, 96, 97, 98, 104, 105, 106, 115, 116, 125, 126, 127, 128, 129, 131, 133, 134, 135, 139, 140, 143, 144, 145, 148, 153, 155, 164, 165, 166, 168, 171, 176, 178, 181, 183, 185, 186, 187, 188, 189, 192, 193, 194, 202, 203, 205, 213, 224, 225, 227, 229, 234, 236, 238, 250, 251, 258, 272, 273, 281, 293, 294, 295, 300, 308, 310, 313, 315, 320, 322, 331, 364, 367, 381, 382, 383, 385], "excluded_lines": []}, "": {"executed_lines": [2, 7, 8, 9, 10, 11, 12, 14, 15, 17, 18, 20, 21, 24, 25, 28, 29, 30, 32, 33, 34, 35, 36, 39, 40, 41, 43, 44, 45, 46, 49, 50, 51, 53, 54, 55, 56, 57, 58, 61, 62, 64, 81, 108, 118, 137, 222, 340, 389, 407, 443], "summary": {"covered_lines": 33, "num_statements": 57, "percent_covered": 57.89473684210526, "percent_covered_display": "58", "missing_lines": 24, "excluded_lines": 0}, "missing_lines": [16, 22, 23, 409, 410, 412, 413, 415, 417, 419, 421, 422, 424, 425, 426, 428, 429, 431, 432, 434, 436, 437, 440, 444], "excluded_lines": []}}}, "tests/test_db_backup.py": {"executed_lines": [1, 3, 4, 5, 6, 7, 9, 12, 14, 17, 18, 20, 21, 22, 25, 26, 28, 39, 40, 42, 44, 53, 54, 55, 56, 57, 58, 61, 62, 64, 66, 68, 69, 71, 72, 74, 76, 77, 84, 85, 86, 87, 89, 90, 92, 94, 96, 97, 99, 106, 110, 112, 113, 120, 122, 123, 125, 127, 129, 132, 139, 140, 141, 143, 145, 148, 151, 152, 155, 156, 157, 158, 159, 161, 163, 166, 169, 171, 172, 173, 175, 176, 178, 180, 183, 184, 186, 191, 192, 194, 195, 197, 199, 202, 203, 205, 206, 208, 213, 215, 217, 219, 224, 226, 228, 231, 232, 234, 240, 242, 244, 247, 248, 251, 252, 255, 257, 258, 260, 262, 265, 266, 268, 269, 272, 274, 275, 277, 279, 282, 283, 285, 287, 289, 291, 294, 295, 297, 299, 301, 303, 305, 306, 307, 308, 310, 312, 314, 315, 317, 319, 321, 323, 325, 326, 327, 328, 330, 332, 336, 339], "summary": {"covered_lines": 158, "num_statements": 161, "percent_covered": 98.13664596273291, "percent_covered_display": "98", "missing_lines": 3, "excluded_lines": 0}, "missing_lines": [107, 108, 340], "excluded_lines": [], "functions": {"temp_backup_dir": {"executed_lines": [20, 21, 22], "summary": {"covered_lines": 3, "num_statements": 3, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "sample_backup_info": {"executed_lines": [28], "summary": {"covered_lines": 1, "num_statements": 1, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupInfo.test_backup_info_creation": {"executed_lines": [44, 53, 54, 55, 56, 57, 58], "summary": {"covered_lines": 7, "num_statements": 7, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_init": {"executed_lines": [66, 68, 69], "summary": {"covered_lines": 3, "num_statements": 3, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_backup_mongodb": {"executed_lines": [74, 76, 77, 84, 85, 86, 87], "summary": {"covered_lines": 7, "num_statements": 7, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_backup_postgres": {"executed_lines": [92, 94, 96, 97, 99, 106], "summary": {"covered_lines": 6, "num_statements": 8, "percent_covered": 75.0, "percent_covered_display": "75", "missing_lines": 2, "excluded_lines": 0}, "missing_lines": [107, 108], "excluded_lines": []}, "TestBackupManager.test_backup_postgres_no_database": {"executed_lines": [112, 113, 120], "summary": {"covered_lines": 3, "num_statements": 3, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_backup_with_compression": {"executed_lines": [125, 127, 129, 132, 139, 140, 141], "summary": {"covered_lines": 7, "num_statements": 7, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_save_and_load_metadata": {"executed_lines": [145, 148, 151, 152, 155, 156, 157, 158, 159], "summary": {"covered_lines": 9, "num_statements": 9, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_list_backups": {"executed_lines": [163, 166, 169, 171, 172, 173], "summary": {"covered_lines": 6, "num_statements": 6, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_restore_mongodb": {"executed_lines": [178, 180, 183, 184, 186, 191, 192], "summary": {"covered_lines": 7, "num_statements": 7, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_restore_postgres": {"executed_lines": [197, 199, 202, 203, 205, 206, 208, 213], "summary": {"covered_lines": 8, "num_statements": 8, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_restore_nonexistent_backup": {"executed_lines": [217, 219, 224], "summary": {"covered_lines": 3, "num_statements": 3, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_restore_dry_run": {"executed_lines": [228, 231, 232, 234, 240], "summary": {"covered_lines": 5, "num_statements": 5, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_cleanup_old_backups": {"executed_lines": [244, 247, 248, 251, 252, 255, 257, 258], "summary": {"covered_lines": 8, "num_statements": 8, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_cleanup_dry_run": {"executed_lines": [262, 265, 266, 268, 269, 272, 274, 275], "summary": {"covered_lines": 8, "num_statements": 8, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_verify_backup": {"executed_lines": [279, 282, 283, 285, 287], "summary": {"covered_lines": 5, "num_statements": 5, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_verify_empty_backup": {"executed_lines": [291, 294, 295, 297, 299], "summary": {"covered_lines": 5, "num_statements": 5, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_format_size": {"executed_lines": [303, 305, 306, 307, 308], "summary": {"covered_lines": 5, "num_statements": 5, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_get_size_file": {"executed_lines": [312, 314, 315, 317, 319], "summary": {"covered_lines": 5, "num_statements": 5, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager.test_get_size_directory": {"executed_lines": [323, 325, 326, 327, 328, 330, 332], "summary": {"covered_lines": 7, "num_statements": 7, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "": {"executed_lines": [1, 3, 4, 5, 6, 7, 9, 12, 14, 17, 18, 25, 26, 39, 40, 42, 61, 62, 64, 71, 72, 89, 90, 110, 122, 123, 143, 161, 175, 176, 194, 195, 215, 226, 242, 260, 277, 289, 301, 310, 321, 336, 339], "summary": {"covered_lines": 40, "num_statements": 41, "percent_covered": 97.5609756097561, "percent_covered_display": "98", "missing_lines": 1, "excluded_lines": 0}, "missing_lines": [340], "excluded_lines": []}}, "classes": {"TestBackupInfo": {"executed_lines": [44, 53, 54, 55, 56, 57, 58], "summary": {"covered_lines": 7, "num_statements": 7, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestBackupManager": {"executed_lines": [66, 68, 69, 74, 76, 77, 84, 85, 86, 87, 92, 94, 96, 97, 99, 106, 112, 113, 120, 125, 127, 129, 132, 139, 140, 141, 145, 148, 151, 152, 155, 156, 157, 158, 159, 163, 166, 169, 171, 172, 173, 178, 180, 183, 184, 186, 191, 192, 197, 199, 202, 203, 205, 206, 208, 213, 217, 219, 224, 228, 231, 232, 234, 240, 244, 247, 248, 251, 252, 255, 257, 258, 262, 265, 266, 268, 269, 272, 274, 275, 279, 282, 283, 285, 287, 291, 294, 295, 297, 299, 303, 305, 306, 307, 308, 312, 314, 315, 317, 319, 323, 325, 326, 327, 328, 330, 332], "summary": {"covered_lines": 107, "num_statements": 109, "percent_covered": 98.1651376146789, "percent_covered_display": "98", "missing_lines": 2, "excluded_lines": 0}, "missing_lines": [107, 108], "excluded_lines": []}, "": {"executed_lines": [1, 3, 4, 5, 6, 7, 9, 12, 14, 17, 18, 20, 21, 22, 25, 26, 28, 39, 40, 42, 61, 62, 64, 71, 72, 89, 90, 110, 122, 123, 143, 161, 175, 176, 194, 195, 215, 226, 242, 260, 277, 289, 301, 310, 321, 336, 339], "summary": {"covered_lines": 44, "num_statements": 45, "percent_covered": 97.77777777777777, "percent_covered_display": "98", "missing_lines": 1, "excluded_lines": 0}, "missing_lines": [340], "excluded_lines": []}}}, "tests/test_db_migrate.py": {"executed_lines": [1, 3, 4, 5, 6, 7, 8, 10, 13, 15, 18, 19, 21, 22, 23, 26, 27, 29, 30, 31, 32, 33, 36, 37, 39, 40, 41, 42, 45, 46, 48, 50, 57, 58, 59, 60, 63, 64, 66, 68, 70, 71, 72, 74, 75, 87, 88, 99, 101, 102, 104, 106, 108, 109, 111, 112, 115, 116, 119, 120, 121, 122, 124, 126, 127, 129, 132, 133, 135, 137, 140, 148, 149, 150, 153, 154, 156, 158, 159, 160, 162, 163, 192, 194, 196, 204, 206, 208, 209, 237, 239, 241, 243, 246, 248, 251, 252, 260, 261, 262, 264, 265, 267, 270, 271, 272, 273, 276], "summary": {"covered_lines": 105, "num_statements": 139, "percent_covered": 75.53956834532374, "percent_covered_display": "76", "missing_lines": 34, "excluded_lines": 0}, "missing_lines": [77, 78, 80, 81, 83, 84, 85, 90, 91, 93, 94, 96, 97, 165, 166, 168, 169, 171, 186, 188, 189, 190, 211, 212, 214, 215, 218, 227, 228, 229, 231, 233, 235, 277], "excluded_lines": [], "functions": {"temp_migrations_dir": {"executed_lines": [21, 22, 23], "summary": {"covered_lines": 3, "num_statements": 3, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "mock_mongo_client": {"executed_lines": [29, 30, 31, 32, 33], "summary": {"covered_lines": 5, "num_statements": 5, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "mock_postgres_conn": {"executed_lines": [39, 40, 41, 42], "summary": {"covered_lines": 4, "num_statements": 4, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestMigration.test_migration_creation": {"executed_lines": [50, 57, 58, 59, 60], "summary": {"covered_lines": 5, "num_statements": 5, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestMigrationManager.test_init": {"executed_lines": [68, 70, 71, 72], "summary": {"covered_lines": 4, "num_statements": 4, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestMigrationManager.test_connect_mongodb": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 7, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 7, "excluded_lines": 0}, "missing_lines": [77, 78, 80, 81, 83, 84, 85], "excluded_lines": []}, "TestMigrationManager.test_connect_postgres": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 6, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 6, "excluded_lines": 0}, "missing_lines": [90, 91, 93, 94, 96, 97], "excluded_lines": []}, "TestMigrationManager.test_connect_unsupported_db": {"executed_lines": [101, 102, 104], "summary": {"covered_lines": 3, "num_statements": 3, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestMigrationManager.test_generate_migration": {"executed_lines": [108, 109, 111, 112, 115, 116, 119, 120, 121, 122], "summary": {"covered_lines": 10, "num_statements": 10, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestMigrationManager.test_generate_migration_dry_run": {"executed_lines": [126, 127, 129, 132, 133], "summary": {"covered_lines": 5, "num_statements": 5, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestMigrationManager.test_get_pending_migrations": {"executed_lines": [137, 140, 148, 149, 150, 153, 154, 156, 158, 159, 160], "summary": {"covered_lines": 11, "num_statements": 11, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestMigrationManager.test_apply_mongodb_migration": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 9, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 9, "excluded_lines": 0}, "missing_lines": [165, 166, 168, 169, 171, 186, 188, 189, 190], "excluded_lines": []}, "TestMigrationManager.test_apply_migration_dry_run": {"executed_lines": [194, 196, 204, 206], "summary": {"covered_lines": 4, "num_statements": 4, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestMigrationManager.test_rollback_postgres_migration": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 11, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 11, "excluded_lines": 0}, "missing_lines": [211, 212, 214, 215, 218, 227, 228, 229, 231, 233, 235], "excluded_lines": []}, "TestMigrationManager.test_rollback_migration_not_found": {"executed_lines": [239, 241, 243], "summary": {"covered_lines": 3, "num_statements": 3, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "test_migration_sorting": {"executed_lines": [248, 251, 252, 260, 261, 262, 264, 265, 267, 270, 271, 272, 273], "summary": {"covered_lines": 13, "num_statements": 13, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "": {"executed_lines": [1, 3, 4, 5, 6, 7, 8, 10, 13, 15, 18, 19, 26, 27, 36, 37, 45, 46, 48, 63, 64, 66, 74, 75, 87, 88, 99, 106, 124, 135, 162, 163, 192, 208, 209, 237, 246, 276], "summary": {"covered_lines": 35, "num_statements": 36, "percent_covered": 97.22222222222223, "percent_covered_display": "97", "missing_lines": 1, "excluded_lines": 0}, "missing_lines": [277], "excluded_lines": []}}, "classes": {"TestMigration": {"executed_lines": [50, 57, 58, 59, 60], "summary": {"covered_lines": 5, "num_statements": 5, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestMigrationManager": {"executed_lines": [68, 70, 71, 72, 101, 102, 104, 108, 109, 111, 112, 115, 116, 119, 120, 121, 122, 126, 127, 129, 132, 133, 137, 140, 148, 149, 150, 153, 154, 156, 158, 159, 160, 194, 196, 204, 206, 239, 241, 243], "summary": {"covered_lines": 40, "num_statements": 73, "percent_covered": 54.794520547945204, "percent_covered_display": "55", "missing_lines": 33, "excluded_lines": 0}, "missing_lines": [77, 78, 80, 81, 83, 84, 85, 90, 91, 93, 94, 96, 97, 165, 166, 168, 169, 171, 186, 188, 189, 190, 211, 212, 214, 215, 218, 227, 228, 229, 231, 233, 235], "excluded_lines": []}, "": {"executed_lines": [1, 3, 4, 5, 6, 7, 8, 10, 13, 15, 18, 19, 21, 22, 23, 26, 27, 29, 30, 31, 32, 33, 36, 37, 39, 40, 41, 42, 45, 46, 48, 63, 64, 66, 74, 75, 87, 88, 99, 106, 124, 135, 162, 163, 192, 208, 209, 237, 246, 248, 251, 252, 260, 261, 262, 264, 265, 267, 270, 271, 272, 273, 276], "summary": {"covered_lines": 60, "num_statements": 61, "percent_covered": 98.36065573770492, "percent_covered_display": "98", "missing_lines": 1, "excluded_lines": 0}, "missing_lines": [277], "excluded_lines": []}}}, "tests/test_db_performance_check.py": {"executed_lines": [1, 3, 4, 5, 6, 7, 9, 12, 14, 19, 20, 22, 23, 24, 25, 26, 29, 30, 32, 33, 34, 35, 38, 39, 41, 43, 49, 50, 51, 54, 55, 57, 59, 66, 67, 68, 69, 72, 73, 75, 77, 86, 87, 88, 89, 90, 93, 94, 96, 98, 100, 101, 102, 104, 105, 117, 118, 129, 131, 132, 134, 136, 137, 194, 195, 242, 244, 246, 272, 274, 275, 276, 277, 280, 282, 284, 293, 294, 296, 298, 299, 300, 301, 303, 305, 308, 309, 311, 313, 314, 316, 317, 333, 334, 336, 337, 369], "summary": {"covered_lines": 91, "num_statements": 160, "percent_covered": 56.875, "percent_covered_display": "57", "missing_lines": 69, "excluded_lines": 0}, "missing_lines": [107, 108, 110, 111, 113, 114, 115, 120, 121, 123, 124, 126, 127, 139, 140, 143, 149, 150, 158, 161, 164, 165, 166, 167, 170, 173, 177, 183, 184, 186, 188, 189, 190, 191, 192, 197, 198, 201, 208, 232, 233, 235, 237, 238, 239, 240, 278, 319, 320, 323, 325, 326, 328, 330, 339, 340, 343, 344, 345, 346, 351, 354, 357, 358, 361, 362, 363, 366, 370], "excluded_lines": [], "functions": {"mock_mongo_client": {"executed_lines": [22, 23, 24, 25, 26], "summary": {"covered_lines": 5, "num_statements": 5, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "mock_postgres_conn": {"executed_lines": [32, 33, 34, 35], "summary": {"covered_lines": 4, "num_statements": 4, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestSlowQuery.test_slow_query_creation": {"executed_lines": [43, 49, 50, 51], "summary": {"covered_lines": 4, "num_statements": 4, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestIndexRecommendation.test_recommendation_creation": {"executed_lines": [59, 66, 67, 68, 69], "summary": {"covered_lines": 5, "num_statements": 5, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestPerformanceReport.test_report_creation": {"executed_lines": [77, 86, 87, 88, 89, 90], "summary": {"covered_lines": 6, "num_statements": 6, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestPerformanceAnalyzer.test_init": {"executed_lines": [98, 100, 101, 102], "summary": {"covered_lines": 4, "num_statements": 4, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestPerformanceAnalyzer.test_connect_mongodb": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 7, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 7, "excluded_lines": 0}, "missing_lines": [107, 108, 110, 111, 113, 114, 115], "excluded_lines": []}, "TestPerformanceAnalyzer.test_connect_postgres": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 6, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 6, "excluded_lines": 0}, "missing_lines": [120, 121, 123, 124, 126, 127], "excluded_lines": []}, "TestPerformanceAnalyzer.test_connect_unsupported_db": {"executed_lines": [131, 132, 134], "summary": {"covered_lines": 3, "num_statements": 3, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestPerformanceAnalyzer.test_analyze_mongodb": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 22, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 22, "excluded_lines": 0}, "missing_lines": [139, 140, 143, 149, 150, 158, 161, 164, 165, 166, 167, 170, 173, 177, 183, 184, 186, 188, 189, 190, 191, 192], "excluded_lines": []}, "TestPerformanceAnalyzer.test_analyze_postgres": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 11, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 11, "excluded_lines": 0}, "missing_lines": [197, 198, 201, 208, 232, 233, 235, 237, 238, 239, 240], "excluded_lines": []}, "TestPerformanceAnalyzer.test_print_report": {"executed_lines": [244, 246, 272, 274, 275, 276, 277], "summary": {"covered_lines": 7, "num_statements": 8, "percent_covered": 87.5, "percent_covered_display": "88", "missing_lines": 1, "excluded_lines": 0}, "missing_lines": [278], "excluded_lines": []}, "TestPerformanceAnalyzer.test_save_report": {"executed_lines": [282, 284, 293, 294, 296, 298, 299, 300, 301], "summary": {"covered_lines": 9, "num_statements": 9, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestPerformanceAnalyzer.test_disconnect": {"executed_lines": [305, 308, 309, 311, 313, 314], "summary": {"covered_lines": 6, "num_statements": 6, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestPerformanceAnalyzer.test_analyze_error_handling": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 7, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 7, "excluded_lines": 0}, "missing_lines": [319, 320, 323, 325, 326, 328, 330], "excluded_lines": []}, "TestIntegration.test_full_mongodb_workflow": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 14, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 14, "excluded_lines": 0}, "missing_lines": [339, 340, 343, 344, 345, 346, 351, 354, 357, 358, 361, 362, 363, 366], "excluded_lines": []}, "": {"executed_lines": [1, 3, 4, 5, 6, 7, 9, 12, 14, 19, 20, 29, 30, 38, 39, 41, 54, 55, 57, 72, 73, 75, 93, 94, 96, 104, 105, 117, 118, 129, 136, 137, 194, 195, 242, 280, 303, 316, 317, 333, 334, 336, 337, 369], "summary": {"covered_lines": 38, "num_statements": 39, "percent_covered": 97.43589743589743, "percent_covered_display": "97", "missing_lines": 1, "excluded_lines": 0}, "missing_lines": [370], "excluded_lines": []}}, "classes": {"TestSlowQuery": {"executed_lines": [43, 49, 50, 51], "summary": {"covered_lines": 4, "num_statements": 4, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestIndexRecommendation": {"executed_lines": [59, 66, 67, 68, 69], "summary": {"covered_lines": 5, "num_statements": 5, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestPerformanceReport": {"executed_lines": [77, 86, 87, 88, 89, 90], "summary": {"covered_lines": 6, "num_statements": 6, "percent_covered": 100.0, "percent_covered_display": "100", "missing_lines": 0, "excluded_lines": 0}, "missing_lines": [], "excluded_lines": []}, "TestPerformanceAnalyzer": {"executed_lines": [98, 100, 101, 102, 131, 132, 134, 244, 246, 272, 274, 275, 276, 277, 282, 284, 293, 294, 296, 298, 299, 300, 301, 305, 308, 309, 311, 313, 314], "summary": {"covered_lines": 29, "num_statements": 83, "percent_covered": 34.93975903614458, "percent_covered_display": "35", "missing_lines": 54, "excluded_lines": 0}, "missing_lines": [107, 108, 110, 111, 113, 114, 115, 120, 121, 123, 124, 126, 127, 139, 140, 143, 149, 150, 158, 161, 164, 165, 166, 167, 170, 173, 177, 183, 184, 186, 188, 189, 190, 191, 192, 197, 198, 201, 208, 232, 233, 235, 237, 238, 239, 240, 278, 319, 320, 323, 325, 326, 328, 330], "excluded_lines": []}, "TestIntegration": {"executed_lines": [], "summary": {"covered_lines": 0, "num_statements": 14, "percent_covered": 0.0, "percent_covered_display": "0", "missing_lines": 14, "excluded_lines": 0}, "missing_lines": [339, 340, 343, 344, 345, 346, 351, 354, 357, 358, 361, 362, 363, 366], "excluded_lines": []}, "": {"executed_lines": [1, 3, 4, 5, 6, 7, 9, 12, 14, 19, 20, 22, 23, 24, 25, 26, 29, 30, 32, 33, 34, 35, 38, 39, 41, 54, 55, 57, 72, 73, 75, 93, 94, 96, 104, 105, 117, 118, 129, 136, 137, 194, 195, 242, 280, 303, 316, 317, 333, 334, 336, 337, 369], "summary": {"covered_lines": 47, "num_statements": 48, "percent_covered": 97.91666666666667, "percent_covered_display": "98", "missing_lines": 1, "excluded_lines": 0}, "missing_lines": [370], "excluded_lines": []}}}}, "totals": {"covered_lines": 681, "num_statements": 1124, "percent_covered": 60.587188612099645, "percent_covered_display": "61", "missing_lines": 443, "excluded_lines": 0}}

package/skills/dev/databases/scripts/tests/requirements.txt

@@ -0,0 +1,4 @@
+pytest>=7.0.0
+pytest-cov>=4.0.0
+pytest-mock>=3.10.0
+mongomock>=4.1.0