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

iris_devtester/fixtures/loader.py

@@ -1,25 +1,29 @@
 import logging
-import time
 import subprocess
+import time
 from pathlib import Path
-from typing import List, Optional
 from subprocess import TimeoutExpired
+from typing import List, Optional
 
 from iris_devtester.containers.iris_container import IRISContainer
-from .manifest import FixtureManifest, LoadResult, FixtureLoadError, FixtureValidationError
+
+from .manifest import FixtureLoadError, FixtureManifest, FixtureValidationError, LoadResult
 
 logger = logging.getLogger(__name__)
 
+
 class DATFixtureLoader:
 
     def __init__(self, container: Optional[IRISContainer] = None, **kwargs):
         self.container = container
-        self.connection_config = kwargs.get('connection_config')
+        self.connection_config = kwargs.get("connection_config")
         self._owns_container = False
 
-    def validate_fixture(self, fixture_path: str, validate_checksum: bool = True) -> FixtureManifest:
-        """Contract‑compatible validation wrapper."""
+    def validate_fixture(
+        self, fixture_path: str, validate_checksum: bool = True
+    ) -> FixtureManifest:
         from .validator import FixtureValidator
+
         validator = FixtureValidator()
         result = validator.validate_fixture(fixture_path, validate_checksum=validate_checksum)
         if not result.valid or result.manifest is None:
@@ -56,95 +60,232 @@ class DATFixtureLoader:
 
             if validate_checksum:
                 from .validator import FixtureValidator
+
                 validator = FixtureValidator()
                 validation = validator.validate_fixture(fixture_path)
                 if not validation.valid:
-                    raise FixtureValidationError(
-                        f"Checksum validation failed: {validation.errors}"
-                    )
+                    raise FixtureValidationError(f"Checksum validation failed: {validation.errors}")
 
             container_name = self.container.get_container_name()
-            container_dat_path = f"/tmp/RESTORE_{namespace}.DAT"
+            container_gof_path = f"/tmp/RESTORE_{namespace}.gof"
+            container_cls_path = f"/tmp/RESTORE_{namespace}.xml"
 
-            subprocess.run([
-                "docker", "cp", str(dat_file_path),
-                f"{container_name}:{container_dat_path}"
-            ], check=True, capture_output=True, text=True)
+            # Step 1: Copy fixture files to container
+            # The fixture package has globals.gof and optionally classes.xml
+            fixture_base = Path(fixture_path)
+            gof_file = fixture_base / "globals.gof"
+            cls_file = fixture_base / "classes.xml"
 
-            db_name = f"DB_{namespace}"
-            db_dir = f"/usr/irissys/mgr/db_{namespace.lower()}"
-
-            refresh_script = ""
-            if force_refresh:
-                refresh_script = f"""
- Set nsName = "{namespace}"
- Set dbName = "{db_name}"
- If ##class(Config.Namespaces).Exists(nsName,.obj) Do ##class(Config.Namespaces).Delete(nsName)
- If ##class(Config.Databases).Exists(dbName,.obj) {{
- Set dir = obj.Directory
- Do ##class(SYS.Database).DismountDatabase(dir)
- Do ##class(Config.Databases).Delete(dbName)
- }}
-"""
+            if gof_file.exists():
+                subprocess.run(
+                    ["docker", "cp", str(gof_file), f"{container_name}:{container_gof_path}"],
+                    check=True,
+                )
             else:
-                refresh_script = f"""
- Do ##class(Config.Namespaces).Exists("{namespace}",.obj,.nsStatus)
- If nsStatus=1 Write "NAMESPACE_EXISTS","SUCCESS" Halt
-"""
+                raise FixtureLoadError(f"globals.gof not found in {fixture_path}")
+
+            has_classes = cls_file.exists()
+            if has_classes:
+                subprocess.run(
+                    ["docker", "cp", str(cls_file), f"{container_name}:{container_cls_path}"],
+                    check=True,
+                )
+
+            # Fix permissions on the copied files
+            subprocess.run(
+                [
+                    "docker",
+                    "exec",
+                    "-u",
+                    "root",
+                    container_name,
+                    "chmod",
+                    "644",
+                    container_gof_path,
+                ],
+                capture_output=True,
+                timeout=30,
+            )
+            if has_classes:
+                subprocess.run(
+                    [
+                        "docker",
+                        "exec",
+                        "-u",
+                        "root",
+                        container_name,
+                        "chmod",
+                        "644",
+                        container_cls_path,
+                    ],
+                    capture_output=True,
+                    timeout=30,
+                )
 
-            objectscript = f"""
+            # Step 2: Create namespace if it doesn't exist, then import globals
+            # First, ensure the namespace exists (create with default database structure)
+            db_dir = f"/usr/irissys/mgr/db_{namespace.lower()}"
+            create_ns_script = f"""
+ Set ns = "{namespace}"
  Set dbDir = "{db_dir}"
- Set dbName = "{db_name}"
- 
- {refresh_script}
- 
+ If ##class(Config.Namespaces).Exists(ns) Write "NS_READY" Halt
  If '##class(%File).DirectoryExists(dbDir) Do ##class(%File).CreateDirectoryChain(dbDir)
- Do ##class(%File).CopyFile("{container_dat_path}",dbDir_"/IRIS.DAT")
- 
- Set dbProps("Directory") = dbDir
- Set status = ##class(Config.Databases).Create(dbName,.dbProps)
- If status'=1 Write "DB_CREATE_FAILED" Halt
- 
- Set status = ##class(SYS.Database).MountDatabase(dbDir)
- 
- Set nsProps("Globals") = dbName
- Set nsProps("Routines") = dbName
- Set status = ##class(Config.Namespaces).Create(nsName,.nsProps)
- If status=1 Write "SUCCESS"
+ Set db = ##class(SYS.Database).%New()
+ Set db.Directory = dbDir
+ Set sc = db.%Save()
+ If 'sc Write "ERR_DB:",$System.Status.GetErrorText(sc) Halt
+ Set sc = ##class(Config.Databases).Create(ns, dbDir)
+ If 'sc Write "ERR_DBCFG:",$System.Status.GetErrorText(sc) Halt
+ Kill p Set p("Globals") = ns, p("Routines") = ns
+ Set sc = ##class(Config.Namespaces).Create(ns, .p)
+ If 'sc Write "ERR_NS:",$System.Status.GetErrorText(sc) Halt
+ Write "NS_READY"
+ Halt
+ """
+            result = subprocess.run(
+                ["docker", "exec", "-i", container_name, "iris", "session", "IRIS", "-U", "%SYS"],
+                input=create_ns_script.encode("utf-8"),
+                capture_output=True,
+                timeout=60,
+            )
+            stdout = result.stdout.decode("utf-8", errors="replace")
+            if "NS_READY" not in stdout:
+                raise FixtureLoadError(f"Namespace creation failed: {stdout}")
+
+            # Step 3a: Import classes FIRST (if available) - this creates SQL table metadata
+            if has_classes:
+                import_cls_script = f"""
+ Set clsFile = "{container_cls_path}"
+ Set sc = $SYSTEM.OBJ.Load(clsFile, "ck")
+ If 'sc Write "ERR_CLS:",$System.Status.GetErrorText(sc) Halt
+ Write "CLASSES_LOADED"
  Halt
-"""
+ """
+                result = subprocess.run(
+                    [
+                        "docker",
+                        "exec",
+                        "-i",
+                        container_name,
+                        "iris",
+                        "session",
+                        "IRIS",
+                        "-U",
+                        namespace,
+                    ],
+                    input=import_cls_script.encode("utf-8"),
+                    capture_output=True,
+                    timeout=120,
+                )
+                stdout = result.stdout.decode("utf-8", errors="replace")
+                logger.info(f"Class import output: {stdout}")
+                if "CLASSES_LOADED" not in stdout and "ERR_CLS" in stdout:
+                    raise FixtureLoadError(f"Class import failed: {stdout}")
 
-            result = subprocess.run([
-                "docker", "exec", "-i", container_name,
-                "iris", "session", "IRIS", "-U", "%SYS"
-            ], input=objectscript.encode('utf-8'), capture_output=True, timeout=60)
+            # Step 3b: Import globals (data)
+            # Signature: Import(Nsp, GlobalList, FileName, InputFormat)
+            # InputFormat=7 for GOF (block format)
+            import_gof_script = f"""
+ Set file = "{container_gof_path}"
+ Set sc = ##class(%Library.Global).Import($Namespace, "*", file, 7)
+ If 'sc Write "ERR_IMPORT:",$System.Status.GetErrorText(sc) Halt
+ Write "SUCCESS"
+ Halt
+ """
+            # Run import in the TARGET namespace so globals go to the right place
+            result = subprocess.run(
+                [
+                    "docker",
+                    "exec",
+                    "-i",
+                    container_name,
+                    "iris",
+                    "session",
+                    "IRIS",
+                    "-U",
+                    namespace,
+                ],
+                input=import_gof_script.encode("utf-8"),
+                capture_output=True,
+                timeout=120,
+            )
 
-            stdout = result.stdout.decode('utf-8', errors='replace')
+            stdout = result.stdout.decode("utf-8", errors="replace")
+            stderr = result.stderr.decode("utf-8", errors="replace")
+            logger.info(f"GOF import output: {stdout}")
+            if stderr:
+                logger.warning(f"GOF import stderr: {stderr}")
             if "SUCCESS" not in stdout:
                 raise FixtureLoadError(f"Restore failed: {stdout}")
 
-            subprocess.run([
-                "docker", "exec", "-u", "root", container_name,
-                "chown", "-R", "irisowner:irisowner", db_dir
-            ], check=False)
-            
-            time.sleep(2)
+            # Step 3: CRITICAL - Ensure test credentials still work after restore
+            # Restoration can sometimes overwrite security settings or trigger flags.
+            ensure_user_script = """
+ Set user="testuser",pass="testpassword"
+ Kill p
+ Set p("PasswordExternal")=pass,p("Roles")="%ALL",p("ChangePassword")=0,p("PasswordNeverExpires")=1
+ If ##class(Security.Users).Exists(user) Do ##class(Security.Users).Delete(user)
+ Set sc=##class(Security.Users).Create(user,.p)
+ Do ##class(Security.Services).Get("%Service_CallIn",.svcP)
+ Set svcP("Enabled")=1
+ Do ##class(Security.Services).Modify("%Service_CallIn",.svcP)
+ If $$$ISERR(sc) Write "ERR:",$System.Status.GetErrorText(sc) Halt
+ Write "SUCCESS" Halt
+ """
+            subprocess.run(
+                ["docker", "exec", "-i", container_name, "iris", "session", "IRIS", "-U", "%SYS"],
+                input=ensure_user_script.encode("utf-8"),
+                capture_output=True,
+                timeout=30,
+            )
+
+            # Also unexpire everything else just in case
+            from iris_devtester.utils.password import unexpire_all_passwords
+
+            unexpire_all_passwords(container_name)
+
+            time.sleep(5)  # Give IRIS a moment to stabilize security changes
 
-        except TimeoutExpired:
-            raise FixtureLoadError("Restore timed out")
         except Exception as e:
-            if isinstance(e, FixtureLoadError): raise
+            if isinstance(e, FixtureLoadError):
+                raise
             raise FixtureLoadError(f"Restore failed: {e}")
 
+        return self._verify_load(namespace, manifest, start_time)
+
+    def _verify_load(
+        self, namespace: str, manifest: FixtureManifest, start_time: float
+    ) -> LoadResult:
+        if not self.container:
+            raise RuntimeError("IRIS container required for verification")
+
         try:
-            from iris_devtester.connections import get_connection
+            # Use the modern connection manager which has automatic password reset remediation
             from iris_devtester.config import IRISConfig
+            from iris_devtester.connections.connection import (
+                get_connection as get_modern_connection,
+            )
+
+            # CRITICAL: Use the provided connection_config if available (has verified testuser credentials)
+            # Otherwise fall back to container's config
+            if self.connection_config:
+                config = self.connection_config
+            else:
+                config = self.container.get_config()
 
-            config = self.container.get_config()
-            conn = get_connection(IRISConfig(
-                host=config.host, port=config.port,
-                namespace=namespace, username=config.username, password=config.password
-            ))
+            # Use the actual container name for remediation if needed
+            container_name = self.container.get_container_name()
+
+            conn = get_modern_connection(
+                IRISConfig(
+                    host=config.host,
+                    port=config.port,
+                    namespace=namespace,
+                    username=config.username,
+                    password=config.password,
+                    container_name=container_name,
+                )
+            )
             cursor = conn.cursor()
             verified_tables = []
             for table_info in manifest.tables:
@@ -155,24 +296,26 @@ class DATFixtureLoader:
             conn.close()
 
             return LoadResult(
-                success=True, manifest=manifest,
-                namespace=namespace, tables_loaded=verified_tables,
-                elapsed_seconds=time.time() - start_time
+                success=True,
+                manifest=manifest,
+                namespace=namespace,
+                tables_loaded=verified_tables,
+                elapsed_seconds=time.time() - start_time,
             )
         except Exception as e:
             raise FixtureLoadError(f"Table verification failed: {e}")
 
     def cleanup_fixture(self, namespace: str, delete_namespace: bool = True):
-        """Contract‑compatible cleanup wrapper."""
         if not namespace:
             raise ValueError("Namespace is required")
         if not self.container:
             raise RuntimeError("IRIS container required for cleanup")
-        
         if delete_namespace:
             self.container.delete_namespace(namespace)
 
     def get_connection(self):
         """Contract‑compatible connection getter."""
-        from iris_devtester.connections import get_connection
-        return get_connection(config=self.connection_config)
+        # Use the modern connection manager which has automatic password reset remediation
+        from iris_devtester.connections.connection import get_connection as get_modern_connection
+
+        return get_modern_connection(config=self.connection_config)

iris_devtester/fixtures/manifest.py

@@ -4,35 +4,40 @@ This module defines the data structures for IRIS .DAT fixture manifests,
 including FixtureManifest, TableInfo, ValidationResult, and LoadResult.
 """
 
-from dataclasses import dataclass, field, asdict
-from typing import List, Dict, Any, Optional
 import json
+from dataclasses import asdict, dataclass, field
 from pathlib import Path
+from typing import Any, Dict, List, Optional
 
 
 # Custom Exceptions
 class FixtureError(Exception):
     """Base exception for fixture operations."""
+
     pass
 
 
 class FixtureValidationError(FixtureError):
     """Raised when fixture validation fails."""
+
     pass
 
 
 class FixtureLoadError(FixtureError):
     """Raised when fixture loading fails."""
+
     pass
 
 
 class FixtureCreateError(FixtureError):
     """Raised when fixture creation fails."""
+
     pass
 
 
 class ChecksumMismatchError(FixtureValidationError):
     """Raised when file checksum doesn't match manifest."""
+
     pass
 
 
@@ -218,10 +223,7 @@ class FixtureManifest:
             errors.append("Duplicate table names found")
 
         return ValidationResult(
-            valid=len(errors) == 0,
-            errors=errors,
-            warnings=warnings,
-            manifest=self
+            valid=len(errors) == 0, errors=errors, warnings=warnings, manifest=self
         )
 
 

iris_devtester/fixtures/obj_export.py

@@ -86,24 +86,26 @@ def export_classes(
     """
     qualifiers = "/displaylog" + ("/compile" if compile else "")
 
-    objectscript = f'''
+    objectscript = f"""
 ZN "{namespace}"
 Set sc = $SYSTEM.OBJ.Export("{pattern}", "{output_file}", "{qualifiers}")
 Write $Select(sc=1:1,1:0)
 Halt
-'''
+"""
 
     try:
         container_name = container.get_container_name()
 
         cmd = [
-            "docker", "exec", container_name, "sh", "-c",
-            f'iris session IRIS -U %SYS << "EOF"\n{objectscript}\nEOF'
+            "docker",
+            "exec",
+            container_name,
+            "sh",
+            "-c",
+            f'iris session IRIS -U %SYS << "EOF"\n{objectscript}\nEOF',
         ]
 
-        result = subprocess.run(
-            cmd, capture_output=True, text=True, timeout=120
-        )
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
 
         raw_output = result.stdout + result.stderr
         success = result.returncode == 0 and "1" in result.stdout
@@ -173,24 +175,26 @@ def import_classes(
     """
     qualifiers = "/displaylog" + ("/compile" if compile else "")
 
-    objectscript = f'''
+    objectscript = f"""
 ZN "{namespace}"
 Set sc = $SYSTEM.OBJ.Import("{input_file}", "{qualifiers}")
 Write $Select(sc=1:1,1:0)
 Halt
-'''
+"""
 
     try:
         container_name = container.get_container_name()
 
         cmd = [
-            "docker", "exec", container_name, "sh", "-c",
-            f'iris session IRIS -U %SYS << "EOF"\n{objectscript}\nEOF'
+            "docker",
+            "exec",
+            container_name,
+            "sh",
+            "-c",
+            f'iris session IRIS -U %SYS << "EOF"\n{objectscript}\nEOF',
         ]
 
-        result = subprocess.run(
-            cmd, capture_output=True, text=True, timeout=120
-        )
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
 
         raw_output = result.stdout + result.stderr
         success = result.returncode == 0 and "1" in result.stdout
@@ -260,23 +264,25 @@ def export_global(
     # Normalize global name (remove leading ^ if present for comparison)
     clean_global = global_name.lstrip("^")
 
-    objectscript = f'''
+    objectscript = f"""
 Set sc = ##class(%Library.Global).Export("{namespace}", "^{clean_global}", "{output_file}")
 Write $Select(sc=1:1,1:0)
 Halt
-'''
+"""
 
     try:
         container_name = container.get_container_name()
 
         cmd = [
-            "docker", "exec", container_name, "sh", "-c",
-            f'iris session IRIS -U %SYS << "EOF"\n{objectscript}\nEOF'
+            "docker",
+            "exec",
+            container_name,
+            "sh",
+            "-c",
+            f'iris session IRIS -U %SYS << "EOF"\n{objectscript}\nEOF',
         ]
 
-        result = subprocess.run(
-            cmd, capture_output=True, text=True, timeout=120
-        )
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
 
         raw_output = result.stdout + result.stderr
         success = result.returncode == 0 and "1" in result.stdout
@@ -342,23 +348,25 @@ def import_global(
         ...     if result.success:
         ...         print("Imported global data")
     """
-    objectscript = f'''
+    objectscript = f"""
 Set sc = ##class(%Library.Global).Import("{namespace}", "{input_file}")
 Write $Select(sc=1:1,1:0)
 Halt
-'''
+"""
 
     try:
         container_name = container.get_container_name()
 
         cmd = [
-            "docker", "exec", container_name, "sh", "-c",
-            f'iris session IRIS -U %SYS << "EOF"\n{objectscript}\nEOF'
+            "docker",
+            "exec",
+            container_name,
+            "sh",
+            "-c",
+            f'iris session IRIS -U %SYS << "EOF"\n{objectscript}\nEOF',
         ]
 
-        result = subprocess.run(
-            cmd, capture_output=True, text=True, timeout=120
-        )
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
 
         raw_output = result.stdout + result.stderr
         success = result.returncode == 0 and "1" in result.stdout
@@ -422,24 +430,26 @@ def export_package(
         ...     if result.success:
         ...         print(f"Exported package to {result.output_file}")
     """
-    objectscript = f'''
+    objectscript = f"""
 ZN "{namespace}"
 Set sc = $SYSTEM.OBJ.ExportPackage("{package_name}", "{output_file}")
 Write $Select(sc=1:1,1:0)
 Halt
-'''
+"""
 
     try:
         container_name = container.get_container_name()
 
         cmd = [
-            "docker", "exec", container_name, "sh", "-c",
-            f'iris session IRIS -U %SYS << "EOF"\n{objectscript}\nEOF'
+            "docker",
+            "exec",
+            container_name,
+            "sh",
+            "-c",
+            f'iris session IRIS -U %SYS << "EOF"\n{objectscript}\nEOF',
         ]
 
-        result = subprocess.run(
-            cmd, capture_output=True, text=True, timeout=120
-        )
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
 
         raw_output = result.stdout + result.stderr
         success = result.returncode == 0 and "1" in result.stdout

iris_devtester/fixtures/validator.py

@@ -9,10 +9,10 @@ from pathlib import Path
 from typing import Optional
 
 from .manifest import (
+    ChecksumMismatchError,
     FixtureManifest,
-    ValidationResult,
     FixtureValidationError,
-    ChecksumMismatchError,
+    ValidationResult,
 )
 
 
@@ -104,8 +104,7 @@ class FixtureValidator:
         """
         if not expected_checksum.startswith("sha256:"):
             raise ValueError(
-                f"Invalid checksum format: {expected_checksum}. "
-                "Must start with 'sha256:'"
+                f"Invalid checksum format: {expected_checksum}. " "Must start with 'sha256:'"
             )
 
         actual_checksum = self.calculate_sha256(file_path, chunk_size)
@@ -212,9 +211,7 @@ class FixtureValidator:
             # Validate checksum if requested
             if validate_checksum:
                 try:
-                    self.validate_checksum(
-                        str(dat_file), manifest.checksum, chunk_size
-                    )
+                    self.validate_checksum(str(dat_file), manifest.checksum, chunk_size)
                 except ChecksumMismatchError:
                     # Re-raise ChecksumMismatchError - it's a critical failure
                     # that requires immediate attention (Constitutional Principle #5)

iris_devtester/integrations/langchain.py

@@ -178,9 +178,7 @@ class LangChainIRISContainer(IRISContainer):
         password = getattr(self, "password", "SYS")
         namespace = getattr(self, "namespace", "USER")
 
-        connection_string = (
-            f"iris://{username}:{password}@{host}:{port}/{namespace}"
-        )
+        connection_string = f"iris://{username}:{password}@{host}:{port}/{namespace}"
 
         return connection_string
 
@@ -247,9 +245,7 @@ class LangChainIRISContainer(IRISContainer):
 
         connection_string = self.get_connection_string()
 
-        logger.info(
-            f"Creating LangChain chat history for session '{session_id}'"
-        )
+        logger.info(f"Creating LangChain chat history for session '{session_id}'")
 
         history = IRISChatMessageHistory(
             connection_string=connection_string,

iris_devtester/ports/registry.py

@@ -192,7 +192,10 @@ class PortRegistry:
                 # Find stale assignments (container doesn't exist)
                 active_assignments = []
                 for assignment in assignments:
-                    if assignment.container_name and assignment.container_name not in container_names:
+                    if (
+                        assignment.container_name
+                        and assignment.container_name not in container_names
+                    ):
                         # Container removed - mark as stale
                         assignment.status = "stale"
                         released.append(assignment)
@@ -298,9 +301,7 @@ class PortRegistry:
                 return port
 
         # All ports exhausted
-        raise PortExhaustedError(
-            port_range=self.port_range, current_assignments=assignments
-        )
+        raise PortExhaustedError(port_range=self.port_range, current_assignments=assignments)
 
     def _get_docker_bound_ports(self) -> set:
         """