feat: add table-driven tests and URL parsing fix

- Add unit tests for headless and timeout parameters (6 tests)
- Add URL parsing tests (15 tests)
- Convert credential sanitization to table-driven (16 tests)
- Expand REDACTED_CASES and PRIVATE_IP_CASES (100 tests)
- Expand SENSITIVE_FIELD_CASES and HEADER_REDACTION_CASES (123 tests)
- Fix URL handling for har-capture get https://example.com
- Skip capture tests when Playwright not installed

Total: 498 tests, 68.5% coverage

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: kwschulz

src/har_capture/capture/browser.py

@@ -15,7 +15,7 @@
 from pathlib import Path
 from typing import Any
 
-from har_capture.capture.connectivity import check_device_connectivity
+from har_capture.capture.connectivity import _parse_target, check_device_connectivity
 from har_capture.capture.deps import check_playwright, install_browser_deps
 from har_capture.patterns import get_bloat_extensions
 
@@ -269,16 +269,19 @@ def capture_device_har(
     if output_path.suffix != ".har":
         output_path = output_path.with_suffix(".har")
 
+    # Parse target to extract hostname (handles URLs like "https://example.com")
+    host, _ = _parse_target(ip)
+
     # Check connectivity and determine scheme
     reachable, scheme, error = check_device_connectivity(ip)
     if not reachable:
         return CaptureResult(
             har_path=output_path,
             success=False,
-            error=error or f"Cannot connect to device at {ip}",
+            error=error or f"Cannot connect to {host}",
         )
 
-    device_url = f"{scheme}://{ip}/"
+    target_url = f"{scheme}://{host}/"
 
     def launch_browser_and_capture() -> bool:
         """Launch browser and capture HAR. Returns True on success."""
@@ -313,7 +316,7 @@ def launch_browser_and_capture() -> bool:
 
             # Create page and navigate to device
             page = context.new_page()
-            page.goto(device_url, wait_until="networkidle")
+            page.goto(target_url, wait_until="networkidle")
 
             if timeout is not None:
                 # Automated mode: wait for timeout then close

src/har_capture/capture/connectivity.py

@@ -1,6 +1,6 @@
-"""Device connectivity checking utilities.
+"""Target connectivity checking utilities.
 
-This module provides functions to check device reachability and authentication
+This module provides functions to check target reachability and authentication
 requirements before launching the browser capture.
 """
 
@@ -10,27 +10,64 @@
 import ssl
 import urllib.error
 import urllib.request
+from urllib.parse import urlparse
 
 _LOGGER = logging.getLogger(__name__)
 
 
-def check_device_connectivity(ip: str, timeout: int = 5) -> tuple[bool, str, str | None]:
-    """Check if device is reachable and determine the correct URL scheme.
+def _parse_target(target: str) -> tuple[str, str | None]:
+    """Parse a target string into hostname and optional scheme.
 
-    Tries HTTP first, then HTTPS if HTTP fails.
+    Handles various input formats:
+    - Full URL: "https://example.com" -> ("example.com", "https")
+    - URL with path: "https://example.com/page" -> ("example.com", "https")
+    - Hostname only: "example.com" -> ("example.com", None)
+    - IP address: "192.168.1.1" -> ("192.168.1.1", None)
+    - IP with port: "192.168.1.1:8080" -> ("192.168.1.1:8080", None)
 
     Args:
-        ip: Device IP address
+        target: URL, hostname, or IP address
+
+    Returns:
+        Tuple of (hostname_with_port, scheme_or_none)
+    """
+    # Check if it looks like a URL (has scheme)
+    if "://" in target:
+        parsed = urlparse(target)
+        host = parsed.netloc or parsed.path.split("/")[0]
+        return host, parsed.scheme
+    # No scheme - return as-is
+    return target, None
+
+
+def check_device_connectivity(target: str, timeout: int = 5) -> tuple[bool, str, str | None]:
+    """Check if target is reachable and determine the correct URL scheme.
+
+    Tries the provided scheme first (if any), otherwise tries HTTP then HTTPS.
+
+    Args:
+        target: URL, hostname, or IP address (e.g., "example.com", "https://example.com", "192.168.1.1")
         timeout: Connection timeout in seconds
 
     Returns:
         Tuple of (reachable, scheme, error_message)
-        - reachable: True if device responded
+        - reachable: True if target responded
         - scheme: "http" or "https"
         - error_message: None if reachable, otherwise describes the problem
     """
-    for scheme in ["http", "https"]:
-        url = f"{scheme}://{ip}/"
+    # Parse target to extract hostname and any provided scheme
+    host, provided_scheme = _parse_target(target)
+
+    # Determine which schemes to try
+    if provided_scheme in ("http", "https"):
+        schemes_to_try = [provided_scheme]
+    else:
+        schemes_to_try = ["http", "https"]
+
+    last_error: str | None = None
+
+    for scheme in schemes_to_try:
+        url = f"{scheme}://{host}/"
         try:
             req = urllib.request.Request(url, method="GET")
             if scheme == "https":
@@ -43,17 +80,15 @@ def check_device_connectivity(ip: str, timeout: int = 5) -> tuple[bool, str, str
                 urllib.request.urlopen(req, timeout=timeout)
             return True, scheme, None
         except urllib.error.HTTPError:
-            # HTTP error means device is reachable (might need auth, that's fine)
+            # HTTP error means target is reachable (might need auth, that's fine)
             return True, scheme, None
         except urllib.error.URLError as e:
             # Connection refused, timeout, etc - try next scheme
-            if scheme == "https":
-                return False, "http", f"Cannot connect to device at {ip}: {e.reason}"
+            last_error = str(e.reason)
         except Exception as e:
-            if scheme == "https":
-                return False, "http", f"Cannot connect to device at {ip}: {e}"
+            last_error = str(e)
 
-    return False, "http", f"Cannot connect to device at {ip}"
+    return False, schemes_to_try[0], f"Cannot connect to {host}: {last_error}"
 
 
 def check_basic_auth(url: str, timeout: int = 5) -> tuple[bool, str | None]: