iris-devtester 1.8.1__py3-none-any.whl → 1.9.1__py3-none-any.whl

iris_devtester/testing/__init__.py

@@ -24,16 +24,19 @@ from iris_devtester.testing.schema_reset import (
 # Compatibility layer for contract tests
 # -----------------------------------------------------------------
 
+
 def validate_schema(connection, schema):
     """Contract‑compatible schema validation wrapper."""
     # Basic implementation for contract tests
     return SchemaValidationResult(is_valid=True, mismatches=[])
 
+
 def register_cleanup(action):
     """Contract‑compatible cleanup registration wrapper."""
     # Global state or dummy for contract test
     return True
 
+
 # Export fixtures module
 from . import fixtures
 

iris_devtester/testing/fixtures.py

@@ -1,33 +1,42 @@
 """Pytest fixtures for InterSystems IRIS development."""
 
-import pytest
 from typing import Any, Generator
 
+import pytest
+
+
 @pytest.fixture
 def iris_db() -> Generator[Any, None, None]:
     """Function‑scoped IRIS database fixture."""
     from iris_devtester.containers import IRISContainer
+
     with IRISContainer.community() as iris:
         yield iris
 
+
 @pytest.fixture(scope="module")
 def iris_db_shared() -> Generator[Any, None, None]:
     """Module‑scoped shared IRIS database fixture."""
     from iris_devtester.containers import IRISContainer
+
     with IRISContainer.community() as iris:
         yield iris
 
+
 @pytest.fixture
 def iris_container() -> Generator[Any, None, None]:
     """Raw IRIS container fixture."""
     from iris_devtester.containers import IRISContainer
+
     with IRISContainer.community() as iris:
         yield iris
 
+
 # Compatibility for contract tests that inspect internal pytest attributes
 class FixtureInfo:
     def __init__(self, scope):
         self.scope = scope
 
+
 for f, s in [(iris_db, "function"), (iris_db_shared, "module"), (iris_container, "function")]:
     setattr(f, "_pytestfixturefunction", FixtureInfo(s))

iris_devtester/testing/helpers.py

@@ -36,16 +36,14 @@ def measure_verification_time(operation_name: str = "operation"):
     yield timing
 
     timing["elapsed_seconds"] = time.time() - timing["start_time"]
-    logger.debug(
-        f"Completed {operation_name} in {timing['elapsed_seconds']:.2f}s"
-    )
+    logger.debug(f"Completed {operation_name} in {timing['elapsed_seconds']:.2f}s")
 
 
 def assert_within_timeout(
     elapsed_seconds: float,
     timeout_seconds: float,
     operation_name: str = "operation",
-    grace_period_seconds: float = 0.5
+    grace_period_seconds: float = 0.5,
 ):
     """
     Assert that operation completed within timeout.
@@ -84,8 +82,7 @@ def assert_within_timeout(
 
 
 def simulate_delayed_password_propagation(
-    delay_seconds: float,
-    callback: Optional[Callable] = None
+    delay_seconds: float, callback: Optional[Callable] = None
 ):
     """
     Simulate password propagation delay for testing.
@@ -135,10 +132,7 @@ def calculate_success_rate(successes: int, total: int) -> float:
 
 
 def assert_success_rate_meets_target(
-    successes: int,
-    total: int,
-    target_rate: float,
-    operation_name: str = "operation"
+    successes: int, total: int, target_rate: float, operation_name: str = "operation"
 ):
     """
     Assert that success rate meets or exceeds target.
@@ -169,6 +163,5 @@ def assert_success_rate_meets_target(
         )
 
     logger.info(
-        f"{operation_name} success rate: {actual_rate:.1f}% "
-        f"(meets target {target_rate:.1f}%)"
+        f"{operation_name} success rate: {actual_rate:.1f}% " f"(meets target {target_rate:.1f}%)"
     )

iris_devtester/testing/models.py

@@ -9,7 +9,6 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any, Dict, List, Literal, Optional
 
-
 # Schema Definition Models (T014)
 
 
@@ -183,7 +182,9 @@ class PasswordResetResult:
         message = f"Password reset failed: {self.error}\n"
         if self.remediation_steps:
             message += "\nManual remediation steps:\n"
-            message += "\n".join(f"  {i+1}. {step}" for i, step in enumerate(self.remediation_steps))
+            message += "\n".join(
+                f"  {i+1}. {step}" for i, step in enumerate(self.remediation_steps)
+            )
         return message
 
 

iris_devtester/testing/schema_reset.py

@@ -227,9 +227,7 @@ def cleanup_test_data(connection: Any, test_id: str) -> int:
                     cursor.execute(f"DELETE FROM {table} WHERE test_id = ?", (test_id,))
                     deleted = cursor.rowcount
                     if deleted > 0:
-                        logger.debug(
-                            f"Deleted {deleted} row(s) from {table} for test_id={test_id}"
-                        )
+                        logger.debug(f"Deleted {deleted} row(s) from {table} for test_id={test_id}")
                     cleaned_count += 1
 
             except Exception as e:

iris_devtester/utils/__init__.py

@@ -1,24 +1,39 @@
 """Utility functions and helpers."""
 
-from iris_devtester.utils.password_reset import (
+from iris_devtester.utils.container_status import get_container_status
+from iris_devtester.utils.enable_callin import enable_callin_service
+from iris_devtester.utils.password import (
+    ErrorType,
+    PasswordResetResult,
+    PasswordResult,
+    VerificationConfig,
+    VerificationResult,
     detect_password_change_required,
     reset_password,
     reset_password_if_needed,
-)
-from iris_devtester.utils.unexpire_passwords import (
     unexpire_all_passwords,
     unexpire_passwords_for_containers,
+    verify_password,
+    verify_password_via_connection,
 )
-from iris_devtester.utils.enable_callin import enable_callin_service
 from iris_devtester.utils.test_connection import test_connection
-from iris_devtester.utils.container_status import get_container_status
 
 __all__ = [
+    # Password utilities (consolidated)
     "detect_password_change_required",
     "reset_password",
     "reset_password_if_needed",
     "unexpire_all_passwords",
     "unexpire_passwords_for_containers",
+    "verify_password",
+    "verify_password_via_connection",
+    # Password result types
+    "ErrorType",
+    "PasswordResetResult",
+    "PasswordResult",
+    "VerificationConfig",
+    "VerificationResult",
+    # Other utilities
     "enable_callin_service",
     "test_connection",
     "get_container_status",

iris_devtester/utils/container_port.py

@@ -50,9 +50,7 @@ def get_container_port(
             str(container_port),
         ]
 
-        result = subprocess.run(
-            cmd, capture_output=True, text=True, timeout=timeout
-        )
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
 
         if result.returncode == 0 and result.stdout.strip():
             # Parse output like "0.0.0.0:55000" or "0.0.0.0:55000\n:::55000"
@@ -66,9 +64,7 @@ def get_container_port(
             return host_port
         else:
             # No port mapping found - container might use fixed ports or not expose this port
-            logger.debug(
-                f"No port mapping found for {container_name}:{container_port}"
-            )
+            logger.debug(f"No port mapping found for {container_name}:{container_port}")
             return None
 
     except subprocess.TimeoutExpired:

iris_devtester/utils/container_status.py

@@ -70,9 +70,7 @@ def get_container_status(
             "{{.Names}}",
         ]
 
-        result = subprocess.run(
-            check_cmd, capture_output=True, text=True, timeout=10
-        )
+        result = subprocess.run(check_cmd, capture_output=True, text=True, timeout=10)
 
         if container_name in result.stdout:
             status_lines.append("Running:    ✓ Yes")
@@ -98,9 +96,7 @@ def get_container_status(
             container_name,
         ]
 
-        result = subprocess.run(
-            health_cmd, capture_output=True, text=True, timeout=10
-        )
+        result = subprocess.run(health_cmd, capture_output=True, text=True, timeout=10)
 
         health_status = result.stdout.strip()
         if health_status and health_status != "<no value>":

iris_devtester/utils/dbapi_compat.py

@@ -26,11 +26,13 @@ Logging Levels:
 - DEBUG: Fallback attempts (modern → legacy)
 - ERROR: No package available
 """
+
+import importlib.metadata
 import logging
 import time
-import importlib.metadata
 from dataclasses import dataclass
-from typing import Callable, Any
+from typing import Any, Callable, Optional
+
 from packaging import version
 
 # Configure module logger
@@ -136,11 +138,23 @@ def detect_dbapi_package() -> DBAPIPackageInfo:
     # Try modern package first (priority per Principle #2)
     # CRITICAL: Use official iris.connect() API, NOT private _DBAPI attribute!
     # See CONSTITUTION.md Principle 8 for empirical evidence that _DBAPI does not exist.
+    modern_available = False
     try:
+        import os
+        import sys
+
         import iris
+
+        modern_available = True
+    except ImportError as e:
+        logger.debug(f"Modern package not available, trying legacy: {e}")
+
+    if modern_available:
         import os
         import sys
 
+        import iris
+
         # Check if connect method is available
         if not hasattr(iris, "connect"):
             # Workaround for pytest module caching issue (from iris-vector-rag v0.5.13)
@@ -150,17 +164,17 @@ def detect_dbapi_package() -> DBAPIPackageInfo:
             logger.debug("iris.connect() not found, attempting to load ELSDK manually")
 
             # Get iris module directory
-            if hasattr(iris, '__file__') and iris.__file__:
+            if hasattr(iris, "__file__") and iris.__file__:
                 iris_dir = os.path.dirname(iris.__file__)
 
                 # Try both _elsdk_.py (v5.3.0+) and _init_elsdk.py (v5.1.2)
-                for elsdk_file in ['_elsdk_.py', '_init_elsdk.py']:
+                for elsdk_file in ["_elsdk_.py", "_init_elsdk.py"]:
                     elsdk_path = os.path.join(iris_dir, elsdk_file)
                     if os.path.exists(elsdk_path):
                         logger.info(f"Found {elsdk_file}, loading to inject DBAPI interface")
                         try:
-                            with open(elsdk_path, 'r') as f:
-                                elsdk_code = compile(f.read(), elsdk_path, 'exec')
+                            with open(elsdk_path, "r") as f:
+                                elsdk_code = compile(f.read(), elsdk_path, "exec")
                             exec(elsdk_code, iris.__dict__)
 
                             if hasattr(iris, "connect"):
@@ -187,10 +201,8 @@ def detect_dbapi_package() -> DBAPIPackageInfo:
             import_path="iris",
             version=pkg_version,
             connect_function=iris.connect,
-            detection_time_ms=elapsed_ms
+            detection_time_ms=elapsed_ms,
         )
-    except ImportError as e:
-        logger.debug(f"Modern package not available, trying legacy: {e}")
 
     # Fall back to legacy package
     try:
@@ -208,7 +220,7 @@ def detect_dbapi_package() -> DBAPIPackageInfo:
             import_path="iris.irissdk",
             version=pkg_version,
             connect_function=iris.irissdk.connect,
-            detection_time_ms=elapsed_ms
+            detection_time_ms=elapsed_ms,
         )
     except ImportError:
         logger.error("No IRIS DBAPI package detected")
@@ -224,12 +236,15 @@ class DBAPIConnectionAdapter:
     Implements singleton pattern for zero overhead.
     """
 
+    _package_info: DBAPIPackageInfo
+
     def __init__(self):
         """Initialize adapter with detected package info."""
         self._package_info = detect_dbapi_package()
 
-    def connect(self, hostname: str, port: int, namespace: str,
-                username: str, password: str, **kwargs) -> Any:
+    def connect(
+        self, hostname: str, port: int, namespace: str, username: str, password: str, **kwargs
+    ) -> Any:
         """Create DBAPI connection using detected package.
 
         Args:
@@ -251,7 +266,7 @@ class DBAPIConnectionAdapter:
             namespace=namespace,
             username=username,
             password=password,
-            **kwargs
+            **kwargs,
         )
 
     def get_package_info(self) -> DBAPIPackageInfo:
@@ -264,7 +279,7 @@ class DBAPIConnectionAdapter:
 
 
 # Global singleton adapter (cached for performance)
-_adapter: DBAPIConnectionAdapter | None = None
+_adapter: Optional[DBAPIConnectionAdapter] = None
 
 
 def _get_adapter() -> DBAPIConnectionAdapter:

iris_devtester/utils/enable_callin.py

@@ -76,9 +76,7 @@ def enable_callin_service(
             "{{.Names}}",
         ]
 
-        result = subprocess.run(
-            check_cmd, capture_output=True, text=True, timeout=timeout
-        )
+        result = subprocess.run(check_cmd, capture_output=True, text=True, timeout=timeout)
 
         if container_name not in result.stdout:
             return (
@@ -116,7 +114,7 @@ def enable_callin_service(
             container_name,
             "bash",
             "-c",
-            f'''echo "set prop(\\"Enabled\\")=1 set prop(\\"AutheEnabled\\")={DEFAULT_AUTHENABLED} write ##class(Security.Services).Modify(\\"%Service_CallIn\\",.prop)" | iris session IRIS -U %SYS''',
+            f"""echo "set prop(\\"Enabled\\")=1 set prop(\\"AutheEnabled\\")={DEFAULT_AUTHENABLED} write ##class(Security.Services).Modify(\\"%Service_CallIn\\",.prop)" | iris session IRIS -U %SYS""",
         ]
 
         result = subprocess.run(
@@ -163,9 +161,9 @@ def enable_callin_service(
             "\n"
             "  2. Try manually enabling CallIn:\n"
             f"     docker exec -it {container_name} iris session IRIS -U %SYS\n"
-            "     Do ##class(Security.Services).Get(\"%Service_CallIn\",.prop)\n"
-            "     Set prop(\"Enabled\")=1\n"
-            "     Do ##class(Security.Services).Modify(\"%Service_CallIn\",.prop)\n"
+            '     Do ##class(Security.Services).Get("%Service_CallIn",.prop)\n'
+            '     Set prop("Enabled")=1\n'
+            '     Do ##class(Security.Services).Modify("%Service_CallIn",.prop)\n'
             "\n"
             "  3. Check IRIS license (Community vs Enterprise):\n"
             "     docker exec {container_name} iris list\n"

iris_devtester/utils/health_checks.py

@@ -68,7 +68,7 @@ _IRIS_STATE_MESSAGES = {
 def wait_for_healthy(
     container: Container,
     timeout: int = 60,
-    progress_callback: Optional[Callable[[str], None]] = None
+    progress_callback: Optional[Callable[[str], None]] = None,
 ) -> ContainerState:
     """
     Wait for container to be fully healthy using multi-layer validation.
@@ -158,17 +158,13 @@ def wait_for_healthy(
                 output = last_log.get("Output", "No output")
 
                 raise RuntimeError(
-                    f"Container health check failed\n"
-                    f"\n"
-                    f"Health check output:\n{output}"
+                    f"Container health check failed\n" f"\n" f"Health check output:\n{output}"
                 )
 
             time.sleep(2)
 
         if elapsed() >= timeout:
-            raise TimeoutError(
-                f"Container health check did not pass within {timeout} seconds"
-            )
+            raise TimeoutError(f"Container health check did not pass within {timeout} seconds")
     else:
         notify("⚠ No Docker health check defined, skipping Layer 2")
 
@@ -190,10 +186,7 @@ def wait_for_healthy(
     else:
         while elapsed() < timeout:
             try:
-                sock = socket.create_connection(
-                    ("localhost", superserver_host_port),
-                    timeout=2
-                )
+                sock = socket.create_connection(("localhost", superserver_host_port), timeout=2)
                 sock.close()
                 notify(f"✓ IRIS SuperServer port {superserver_host_port} is accessible")
                 break
@@ -201,9 +194,7 @@ def wait_for_healthy(
                 time.sleep(2)
 
         if elapsed() >= timeout:
-            raise TimeoutError(
-                f"IRIS SuperServer port not accessible within {timeout} seconds"
-            )
+            raise TimeoutError(f"IRIS SuperServer port not accessible within {timeout} seconds")
 
     # Layer 4: Wait for IRIS Monitor.State() to be OK
     # This is the official IRIS health check - more reliable than just port check
@@ -346,9 +337,7 @@ def wait_for_port(port: int, host: str = "localhost", timeout: int = 60) -> None
 
         time.sleep(1)
 
-    raise TimeoutError(
-        f"Port {port} on {host} did not become accessible within {timeout} seconds"
-    )
+    raise TimeoutError(f"Port {port} on {host} did not become accessible within {timeout} seconds")
 
 
 def get_container_logs(container: Container, tail: int = 100) -> str:
@@ -390,17 +379,14 @@ def enable_callin_service(container: Container) -> None:
     """
     # Execute ObjectScript to enable CallIn
     objectscript_cmd = (
-        'iris session iris -U%SYS '
-        '"Do ##class(Security.Services).Get(\"%Service_CallIn\", .service) '
-        'Set service.Enabled = 1 '
-        'Do ##class(Security.Services).Modify(\"%Service_CallIn\", .service)"'
+        "iris session iris -U%SYS "
+        '"Do ##class(Security.Services).Get("%Service_CallIn", .service) '
+        "Set service.Enabled = 1 "
+        'Do ##class(Security.Services).Modify("%Service_CallIn", .service)"'
     )
 
     try:
-        exit_code, output = container.exec_run(
-            cmd=["sh", "-c", objectscript_cmd],
-            user="irisowner"
-        )
+        exit_code, output = container.exec_run(cmd=["sh", "-c", objectscript_cmd], user="irisowner")
 
         if exit_code != 0:
             raise RuntimeError(
@@ -454,16 +440,13 @@ def check_iris_monitor_state(container: Container) -> IrisMonitorResult:
     # ObjectScript command to get Monitor state
     # Use $SYSTEM.Monitor.State() which returns 0=OK, 1=Warning, 2=Error, 3=Fatal
     # Note: ##class(%SYSTEM.System).GetInstanceState() does NOT exist in Community Edition
-    objectscript_cmd = '''iris session IRIS -U %SYS << 'EOF'
+    objectscript_cmd = """iris session IRIS -U %SYS << 'EOF'
 Write $SYSTEM.Monitor.State()
 Halt
-EOF'''
+EOF"""
 
     try:
-        exit_code, output = container.exec_run(
-            cmd=["sh", "-c", objectscript_cmd],
-            user="irisowner"
-        )
+        exit_code, output = container.exec_run(cmd=["sh", "-c", objectscript_cmd], user="irisowner")
 
         raw_output = output.decode("utf-8", errors="ignore")
 
@@ -479,7 +462,9 @@ EOF'''
         # -1 means "monitoring not configured" - treat as healthy since container is running
         # The output may contain prompts/banners, so look for the number on its own line
         # Check for -1 first (monitoring unconfigured), then 0-3
-        match = re.search(r'(?:^|\n)(-1)\s*(?:\n|$)', raw_output) or re.search(r'(?:^|\n)([0-3])\s*(?:\n|$)', raw_output)
+        match = re.search(r"(?:^|\n)(-1)\s*(?:\n|$)", raw_output) or re.search(
+            r"(?:^|\n)([0-3])\s*(?:\n|$)", raw_output
+        )
         if match:
             state_value = int(match.group(1))
             # Handle -1 (monitoring unconfigured) as OK since container is running
@@ -518,7 +503,7 @@ EOF'''
 def wait_for_iris_healthy(
     container: Container,
     timeout: int = 60,
-    progress_callback: Optional[Callable[[str], None]] = None
+    progress_callback: Optional[Callable[[str], None]] = None,
 ) -> bool:
     """Wait for IRIS container to reach healthy state.
 

iris_devtester/utils/iris_container_adapter.py

@@ -167,9 +167,7 @@ class ContainerPersistenceCheck:
 
 
 def verify_container_persistence(
-    container_name: str,
-    config: ContainerConfig,
-    wait_seconds: float = 2.0
+    container_name: str, config: ContainerConfig, wait_seconds: float = 2.0
 ) -> ContainerPersistenceCheck:
     """
     Verify that container persists after creation (Feature 011 - T014).
@@ -214,7 +212,11 @@ def verify_container_persistence(
             status=container.status,
             volume_mounts_verified=volumes_ok,
             verification_time=wait_seconds,
-            error_details=None if volumes_ok else f"Expected {expected_volumes} volumes, found {actual_volumes}"
+            error_details=(
+                None
+                if volumes_ok
+                else f"Expected {expected_volumes} volumes, found {actual_volumes}"
+            ),
         )
 
     except NotFound:
@@ -224,7 +226,7 @@ def verify_container_persistence(
             status=None,
             volume_mounts_verified=False,
             verification_time=wait_seconds,
-            error_details="Container not found after creation (possibly removed by ryuk or failed to start)"
+            error_details="Container not found after creation (possibly removed by ryuk or failed to start)",
         )
 
     except Exception as e:
@@ -234,7 +236,7 @@ def verify_container_persistence(
             status=None,
             volume_mounts_verified=False,
             verification_time=wait_seconds,
-            error_details=f"Verification error: {str(e)}"
+            error_details=f"Verification error: {str(e)}",
         )
 
     finally:
@@ -245,10 +247,7 @@ class IRISContainerManager:
     """Manager for IRIS containers using testcontainers-iris."""
 
     @staticmethod
-    def create_from_config(
-        config: ContainerConfig,
-        use_testcontainers: bool = True
-    ) -> Container:
+    def create_from_config(config: ContainerConfig, use_testcontainers: bool = True) -> Container:
         """
         Create IRIS container from config with dual-mode support (Feature 011 - T012).
 
@@ -287,7 +286,7 @@ class IRISContainerManager:
             username="_SYSTEM",  # IRIS default user
             password=config.password,
             namespace=config.namespace,
-            license_key=config.license_key if config.edition == "enterprise" else None
+            license_key=config.license_key if config.edition == "enterprise" else None,
         )
 
         # Configure container name
@@ -321,34 +320,32 @@ class IRISContainerManager:
         volumes = {}
         for volume_str in config.volumes:
             spec = VolumeMountSpec.parse(volume_str)
-            volumes[spec.host_path] = {
-                'bind': spec.container_path,
-                'mode': spec.mode
-            }
+            volumes[spec.host_path] = {"bind": spec.container_path, "mode": spec.mode}
 
         # IRIS environment variables (Feature 011 - T012)
         # Note: Don't set ISC_DATA_DIRECTORY - let IRIS use its default
         environment = {}
 
         # Add license key for Enterprise edition
-        if config.edition == 'enterprise' and config.license_key:
-            environment['ISC_LICENSE_KEY'] = config.license_key
+        if config.edition == "enterprise" and config.license_key:
+            environment["ISC_LICENSE_KEY"] = config.license_key
 
         if config.cpf_merge:
             import os
             import tempfile
+
             container_path = "/usr/irissys/merge.cpf"
-            environment['ISC_CPF_MERGE_FILE'] = container_path
-            
+            environment["ISC_CPF_MERGE_FILE"] = container_path
+
             cpf_source = config.cpf_merge
             if os.path.exists(cpf_source) and os.path.isfile(cpf_source):
                 host_path = os.path.abspath(cpf_source)
             else:
-                with tempfile.NamedTemporaryFile(mode='w', suffix='.cpf', delete=False) as f:
+                with tempfile.NamedTemporaryFile(mode="w", suffix=".cpf", delete=False) as f:
                     f.write(cpf_source)
                     host_path = f.name
-            
-            volumes[host_path] = {'bind': container_path, 'mode': 'ro'}
+
+            volumes[host_path] = {"bind": container_path, "mode": "ro"}
 
         # Create container without testcontainers labels (prevents ryuk cleanup)
         container = client.containers.create(
@@ -356,11 +353,11 @@ class IRISContainerManager:
             name=config.container_name,
             volumes=volumes or None,
             ports={
-                f'{config.superserver_port}/tcp': config.superserver_port,
-                f'{config.webserver_port}/tcp': config.webserver_port
+                f"{config.superserver_port}/tcp": config.superserver_port,
+                f"{config.webserver_port}/tcp": config.webserver_port,
             },
             environment=environment,
-            detach=True
+            detach=True,
         )
 
         # Start the container
@@ -514,7 +511,11 @@ def translate_docker_error(error: Exception, config: Optional[ContainerConfig])
         )
 
     # Image not found
-    if "image not found" in error_str or "manifest unknown" in error_str or "no such image" in error_str:
+    if (
+        "image not found" in error_str
+        or "manifest unknown" in error_str
+        or "no such image" in error_str
+    ):
         image = config.get_image_name() if config else "unknown"
         return ValueError(
             f"Docker image '{image}' not found\n"