provide-testkit 0.0.0.dev0__py3-none-any.whl

provide/testkit/quality/security/scanner.py

@@ -0,0 +1,338 @@
+"""Security vulnerability scanner implementation."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import time
+from typing import Any
+
+from provide.foundation.file import atomic_write_text, ensure_dir
+
+try:
+    import bandit  # type: ignore[import-untyped]
+    from bandit.core import (
+        config as bandit_config,  # type: ignore[import-untyped]
+        manager as bandit_manager,
+    )
+
+    BANDIT_AVAILABLE = True
+except ImportError:
+    BANDIT_AVAILABLE = False
+    bandit = None
+    bandit_config = None
+    bandit_manager = None
+
+from ..base import QualityResult, QualityToolError
+
+
+class SecurityScanner:
+    """Security vulnerability scanner using bandit and other tools.
+
+    Provides high-level interface for security analysis with automatic
+    artifact management and integration with the quality framework.
+    """
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        """Initialize security scanner.
+
+        Args:
+            config: Security scanner configuration options
+        """
+        if not BANDIT_AVAILABLE:
+            raise QualityToolError("Bandit not available. Install with: pip install bandit", tool="security")
+
+        self.config = config or {}
+        self.artifact_dir: Path | None = None
+
+    def analyze(self, path: Path, **kwargs: Any) -> QualityResult:
+        """Run security analysis on the given path.
+
+        Args:
+            path: Path to analyze
+            **kwargs: Additional options including artifact_dir
+
+        Returns:
+            QualityResult with security analysis data
+        """
+        self.artifact_dir = kwargs.get("artifact_dir", Path(".security"))
+        start_time = time.time()
+
+        try:
+            # Run bandit security scan
+            result = self._run_bandit_scan(path)
+            result.execution_time = time.time() - start_time
+
+            # Generate artifacts
+            self._generate_artifacts(result)
+
+            return result
+
+        except Exception as e:
+            return QualityResult(
+                tool="security",
+                passed=False,
+                details={"error": str(e), "error_type": type(e).__name__},
+                execution_time=time.time() - start_time,
+            )
+
+    def _run_bandit_scan(self, path: Path) -> QualityResult:
+        """Run bandit security scan."""
+        if not BANDIT_AVAILABLE:
+            raise QualityToolError("Bandit not available", tool="security")
+
+        try:
+            # Create bandit configuration
+            conf = bandit_config.BanditConfig()
+
+            # Apply custom configuration
+            self._apply_bandit_config(conf)
+
+            # Create bandit manager
+            b_mgr = bandit_manager.BanditManager(conf, "file")
+
+            # Discover files to scan
+            if path.is_file():
+                files_list = [str(path)]
+            else:
+                files_list = self._discover_python_files(path)
+
+            if not files_list:
+                return QualityResult(
+                    tool="security",
+                    passed=True,
+                    score=100.0,
+                    details={"message": "No Python files found to scan"},
+                )
+
+            # Run the scan
+            b_mgr.discover_files(files_list)
+            b_mgr.run_tests()
+
+            # Process results
+            return self._process_bandit_results(b_mgr)
+
+        except Exception as e:
+            raise QualityToolError(f"Bandit scan failed: {e!s}", tool="security")
+
+    def _apply_bandit_config(self, conf: Any) -> None:
+        """Apply custom configuration to bandit."""
+        # Bandit configuration is set differently than expected
+        # For now, we'll use the defaults and apply filtering later
+        pass
+
+    def _discover_python_files(self, path: Path) -> list[str]:
+        """Discover Python files to scan."""
+        excludes = self.config.get(
+            "exclude", ["*/tests/*", "*/test_*", "*/.venv/*", "*/venv/*", "*/__pycache__/*"]
+        )
+
+        files = []
+        for py_file in path.rglob("*.py"):
+            # Check if file should be excluded
+            if any(py_file.match(pattern) for pattern in excludes):
+                continue
+            files.append(str(py_file))
+
+        return files
+
+    def _process_bandit_results(self, manager: Any) -> QualityResult:
+        """Process bandit scan results into QualityResult."""
+        # Get issues
+        issues = manager.get_issue_list()
+
+        # Calculate metrics
+        total_files = len(manager.files_list)
+        issue_count = len(issues)
+
+        # Categorize by severity
+        severity_counts = {"HIGH": 0, "MEDIUM": 0, "LOW": 0}
+        confidence_counts = {"HIGH": 0, "MEDIUM": 0, "LOW": 0}
+
+        for issue in issues:
+            severity_counts[issue.severity] += 1
+            confidence_counts[issue.confidence] += 1
+
+        # Calculate security score (0-100)
+        # Start at 100, deduct points based on severity
+        score = 100.0
+        score -= severity_counts["HIGH"] * 10  # High severity: -10 points each
+        score -= severity_counts["MEDIUM"] * 5  # Medium severity: -5 points each
+        score -= severity_counts["LOW"] * 1  # Low severity: -1 point each
+        score = max(0.0, score)  # Don't go below 0
+
+        # Determine if passed based on configuration
+        max_high = self.config.get("max_high_severity", 0)
+        max_medium = self.config.get("max_medium_severity", 5)
+        min_score = self.config.get("min_score", 80.0)
+
+        passed = (
+            severity_counts["HIGH"] <= max_high
+            and severity_counts["MEDIUM"] <= max_medium
+            and score >= min_score
+        )
+
+        # Create detailed results
+        details = {
+            "total_files": total_files,
+            "total_issues": issue_count,
+            "severity_breakdown": severity_counts,
+            "confidence_breakdown": confidence_counts,
+            "score": score,
+            "thresholds": {
+                "max_high_severity": max_high,
+                "max_medium_severity": max_medium,
+                "min_score": min_score,
+            },
+        }
+
+        # Add issue details for reporting
+        if issues:
+            details["issues"] = [
+                {
+                    "filename": issue.fname,
+                    "line_number": issue.lineno,
+                    "test_id": issue.test_id,
+                    "test_name": issue.test,
+                    "severity": issue.severity,
+                    "confidence": issue.confidence,
+                    "text": issue.text.strip(),
+                    "code": issue.get_code(max_lines=3, tabbed=False),
+                }
+                for issue in issues[:20]  # Limit to first 20 for readability
+            ]
+
+        return QualityResult(tool="security", passed=passed, score=score, details=details)
+
+    def _generate_artifacts(self, result: QualityResult) -> None:
+        """Generate security analysis artifacts.
+
+        Args:
+            result: Result to add artifacts to
+        """
+        if not self.artifact_dir:
+            return
+
+        ensure_dir(self.artifact_dir)
+
+        try:
+            # Generate JSON report
+            json_file = self.artifact_dir / "security.json"
+            json_data = {
+                "tool": result.tool,
+                "passed": result.passed,
+                "score": result.score,
+                "details": result.details,
+                "execution_time": result.execution_time,
+            }
+            atomic_write_text(json_file, json.dumps(json_data, indent=2))
+            result.artifacts.append(json_file)
+
+            # Generate text summary
+            summary_file = self.artifact_dir / "security_summary.txt"
+            summary_report = self._generate_text_report(result)
+            atomic_write_text(summary_file, summary_report)
+            result.artifacts.append(summary_file)
+
+            # Generate detailed issues report if there are issues
+            if result.details.get("issues"):
+                issues_file = self.artifact_dir / "security_issues.txt"
+                issues_report = self._generate_issues_report(result)
+                atomic_write_text(issues_file, issues_report)
+                result.artifacts.append(issues_file)
+
+        except Exception as e:
+            # Add error to result details but don't fail
+            result.details["artifact_error"] = str(e)
+
+    def _generate_text_report(self, result: QualityResult) -> str:
+        """Generate text summary report."""
+        lines = [
+            f"Security Analysis Report - {result.tool}",
+            "=" * 50,
+            f"Status: {'✅ PASSED' if result.passed else '❌ FAILED'}",
+            f"Security Score: {result.score}%",
+        ]
+
+        details = result.details
+        if "total_files" in details:
+            lines.extend(
+                [
+                    f"Files Scanned: {details['total_files']}",
+                    f"Total Issues: {details['total_issues']}",
+                    "",
+                    "Severity Breakdown:",
+                ]
+            )
+
+            severity = details.get("severity_breakdown", {})
+            for level, count in severity.items():
+                lines.append(f"  {level}: {count}")
+
+            lines.extend(
+                [
+                    "",
+                    "Confidence Breakdown:",
+                ]
+            )
+
+            confidence = details.get("confidence_breakdown", {})
+            for level, count in confidence.items():
+                lines.append(f"  {level}: {count}")
+
+        if result.execution_time:
+            lines.append(f"\nExecution Time: {result.execution_time:.2f}s")
+
+        return "\n".join(lines)
+
+    def _generate_issues_report(self, result: QualityResult) -> str:
+        """Generate detailed issues report."""
+        lines = ["Security Issues Report", "=" * 50, ""]
+
+        issues = result.details.get("issues", [])
+        for i, issue in enumerate(issues, 1):
+            lines.extend(
+                [
+                    f"Issue #{i}:",
+                    f"  File: {issue['filename']}:{issue['line_number']}",
+                    f"  Test: {issue['test_name']} ({issue['test_id']})",
+                    f"  Severity: {issue['severity']} | Confidence: {issue['confidence']}",
+                    f"  Description: {issue['text']}",
+                    "",
+                    "  Code:",
+                ]
+            )
+
+            # Add code snippet with indentation
+            for code_line in issue["code"].split("\n"):
+                if code_line.strip():
+                    lines.append(f"    {code_line}")
+
+            lines.append("")
+
+        return "\n".join(lines)
+
+    def report(self, result: QualityResult, format: str = "terminal") -> str:
+        """Generate report from QualityResult (implements QualityTool protocol).
+
+        Args:
+            result: Security result
+            format: Report format
+
+        Returns:
+            Formatted report
+        """
+        if format == "terminal":
+            return self._generate_text_report(result)
+        elif format == "json":
+            return json.dumps(
+                {
+                    "tool": result.tool,
+                    "passed": result.passed,
+                    "score": result.score,
+                    "details": result.details,
+                },
+                indent=2,
+            )
+        else:
+            return str(result.details)

provide/testkit/streams.py

@@ -0,0 +1,54 @@
+#
+# streams.py
+#
+"""
+Stream Testing Utilities for Foundation.
+
+Provides utilities for redirecting and managing streams during testing,
+allowing tests to capture and control Foundation's output streams.
+"""
+
+from typing import TextIO
+
+# Import the actual stream management variables
+from provide.foundation.streams.core import get_log_stream
+
+
+def set_log_stream_for_testing(stream: TextIO | None) -> None:
+    """
+    Set the log stream for testing purposes.
+
+    This allows tests to redirect Foundation's log output to a custom stream
+    (like StringIO) for capturing and verifying log messages.
+
+    Args:
+        stream: Stream to redirect to, or None to reset to stderr
+    """
+    # Import the actual implementation from streams.core
+    from provide.foundation.streams.core import (
+        set_log_stream_for_testing as _set_stream,
+    )
+
+    _set_stream(stream)
+
+
+def get_current_log_stream() -> TextIO:
+    """
+    Get the currently active log stream.
+
+    Returns:
+        The current log stream being used by Foundation
+    """
+    return get_log_stream()
+
+
+def reset_log_stream() -> None:
+    """Reset log stream back to stderr."""
+    set_log_stream_for_testing(None)
+
+
+__all__ = [
+    "get_current_log_stream",
+    "reset_log_stream",
+    "set_log_stream_for_testing",
+]

provide/testkit/threading/__init__.py

@@ -0,0 +1,38 @@
+"""
+Threading testing utilities for the provide-io ecosystem.
+
+Fixtures and utilities for testing multi-threaded code, thread synchronization,
+and concurrent operations across any project that depends on provide.foundation.
+"""
+
+from provide.testkit.threading.fixtures import (
+    concurrent_executor,
+    deadlock_detector,
+    mock_thread,
+    test_thread,
+    thread_barrier,
+    thread_condition,
+    thread_event,
+    thread_exception_handler,
+    thread_local_storage,
+    thread_pool,
+    thread_safe_counter,
+    thread_safe_list,
+    thread_synchronizer,
+)
+
+__all__ = [
+    "concurrent_executor",
+    "deadlock_detector",
+    "mock_thread",
+    "test_thread",
+    "thread_barrier",
+    "thread_condition",
+    "thread_event",
+    "thread_exception_handler",
+    "thread_local_storage",
+    "thread_pool",
+    "thread_safe_counter",
+    "thread_safe_list",
+    "thread_synchronizer",
+]

provide/testkit/threading/basic_fixtures.py

@@ -0,0 +1,103 @@
+"""
+Basic threading test fixtures.
+
+Core fixtures for creating threads, thread pools, mocks, and thread-local storage.
+"""
+
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+import threading
+from unittest.mock import Mock
+
+import pytest
+
+
+@pytest.fixture
+def test_thread():
+    """
+    Create a test thread with automatic cleanup.
+
+    Returns:
+        Function to create and manage test threads.
+    """
+    threads = []
+
+    def _create_thread(
+        target: Callable, args: tuple = (), kwargs: dict = None, daemon: bool = True
+    ) -> threading.Thread:
+        """
+        Create a test thread.
+
+        Args:
+            target: Function to run in thread
+            args: Positional arguments for target
+            kwargs: Keyword arguments for target
+            daemon: Whether thread should be daemon
+
+        Returns:
+            Started thread instance
+        """
+        kwargs = kwargs or {}
+        thread = threading.Thread(target=target, args=args, kwargs=kwargs, daemon=daemon)
+        threads.append(thread)
+        thread.start()
+        return thread
+
+    yield _create_thread
+
+    # Cleanup: wait for all threads to complete
+    for thread in threads:
+        if thread.is_alive():
+            thread.join(timeout=1.0)
+
+
+@pytest.fixture
+def thread_pool():
+    """
+    Create a thread pool executor for testing.
+
+    Returns:
+        ThreadPoolExecutor instance with automatic cleanup.
+    """
+    executor = ThreadPoolExecutor(max_workers=4)
+    yield executor
+    executor.shutdown(wait=True, cancel_futures=True)
+
+
+@pytest.fixture
+def mock_thread():
+    """
+    Create a mock thread for testing without actual threading.
+
+    Returns:
+        Mock thread object.
+    """
+    mock = Mock(spec=threading.Thread)
+    mock.is_alive.return_value = False
+    mock.daemon = False
+    mock.name = "MockThread"
+    mock.ident = 12345
+    mock.start = Mock()
+    mock.join = Mock()
+    mock.run = Mock()
+
+    return mock
+
+
+@pytest.fixture
+def thread_local_storage():
+    """
+    Create thread-local storage for testing.
+
+    Returns:
+        Thread-local storage object.
+    """
+    return threading.local()
+
+
+__all__ = [
+    "mock_thread",
+    "test_thread",
+    "thread_local_storage",
+    "thread_pool",
+]

provide/testkit/threading/data_fixtures.py

@@ -0,0 +1,101 @@
+"""
+Thread-safe data structure test fixtures.
+
+Fixtures for thread-safe lists, counters, and other data structures for testing.
+"""
+
+import threading
+from typing import Any
+
+import pytest
+
+
+@pytest.fixture
+def thread_safe_list():
+    """
+    Create a thread-safe list for collecting results.
+
+    Returns:
+        Thread-safe list implementation.
+    """
+
+    class ThreadSafeList:
+        def __init__(self):
+            self._list = []
+            self._lock = threading.Lock()
+
+        def append(self, item: Any):
+            """Thread-safe append."""
+            with self._lock:
+                self._list.append(item)
+
+        def extend(self, items):
+            """Thread-safe extend."""
+            with self._lock:
+                self._list.extend(items)
+
+        def get_all(self) -> list:
+            """Get copy of all items."""
+            with self._lock:
+                return self._list.copy()
+
+        def clear(self):
+            """Clear the list."""
+            with self._lock:
+                self._list.clear()
+
+        def __len__(self) -> int:
+            with self._lock:
+                return len(self._list)
+
+        def __getitem__(self, index):
+            with self._lock:
+                return self._list[index]
+
+    return ThreadSafeList()
+
+
+@pytest.fixture
+def thread_safe_counter():
+    """
+    Create a thread-safe counter.
+
+    Returns:
+        Thread-safe counter implementation.
+    """
+
+    class ThreadSafeCounter:
+        def __init__(self, initial: int = 0):
+            self._value = initial
+            self._lock = threading.Lock()
+
+        def increment(self, amount: int = 1) -> int:
+            """Thread-safe increment."""
+            with self._lock:
+                self._value += amount
+                return self._value
+
+        def decrement(self, amount: int = 1) -> int:
+            """Thread-safe decrement."""
+            with self._lock:
+                self._value -= amount
+                return self._value
+
+        @property
+        def value(self) -> int:
+            """Get current value."""
+            with self._lock:
+                return self._value
+
+        def reset(self, value: int = 0):
+            """Reset counter."""
+            with self._lock:
+                self._value = value
+
+    return ThreadSafeCounter()
+
+
+__all__ = [
+    "thread_safe_counter",
+    "thread_safe_list",
+]