iris-devtester 1.19.2__tar.gz → 1.19.3__tar.gz

{iris_devtester-1.19.2 → iris_devtester-1.19.3}/CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to iris-devtester will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.19.3] - 2026-08-02 - Fix attach() ignoring explicit port override
+
+### Fixed
+
+- **`IRISContainer.attach()` ignores explicit port, always uses docker port lookup** (`containers/iris_container.py`): `attach()` had no port parameter. It always derived the host-side SuperServer port from `docker port <container> 1972/tcp`, which fails on macOS Docker Desktop with irishealth enterprise: Docker Desktop NAT rewrites the source IP from `127.0.0.1` to a bridge address, so IRIS RSTs the connection even though the port binding exists. The user-supplied `IVG_PORT=31971` was silently ignored. Added `port: Optional[int]` to `attach()`; when supplied, `_mapped_port` is pinned immediately so `get_mapped_port(1972)` returns it without calling `get_exposed_port()`. Also reads `IVG_PORT` and `IRIS_PORT` env vars as fallbacks when `port=` is not passed explicitly.
+
 ## [1.19.2] - 2026-07-30 - Fix connect_function ImportError when module absent from sys.modules
 
 ### Fixed

{iris_devtester-1.19.2/iris_devtester.egg-info → iris_devtester-1.19.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-devtester
-Version: 1.19.2
+Version: 1.19.3
 Summary: Battle-tested InterSystems IRIS infrastructure utilities for Python development
 Author-email: InterSystems Community <community@intersystems.com>
 Maintainer-email: Thomas Dyar <thomas.dyar@intersystems.com>

{iris_devtester-1.19.2 → iris_devtester-1.19.3}/iris_devtester/__init__.py

@@ -26,7 +26,7 @@ LangChain Integration:
     ...     # Build your RAG app...
 """
 
-__version__ = "1.19.2"
+__version__ = "1.19.3"
 __author__ = "InterSystems Community"
 __license__ = "MIT"
 

{iris_devtester-1.19.2 → iris_devtester-1.19.3}/iris_devtester/containers/cpf_manager.py

@@ -40,15 +40,18 @@ class TempCPFManager:
             file_path = os.path.abspath(tmp.name)
             self._temp_files.add(file_path)
 
-            # Register for automatic cleanup
-            weakref.finalize(self, self._delete_file, file_path)
+            # Register for automatic cleanup.
+            # Must use the unbound method — passing self._delete_file would hold
+            # a strong reference to self through the bound method, preventing GC.
+            weakref.finalize(self, TempCPFManager._delete_file, file_path)
 
             logger.debug(f"Created temporary CPF file: {file_path}")
             return file_path
         finally:
             tmp.close()
 
-    def _delete_file(self, file_path: str):
+    @staticmethod
+    def _delete_file(file_path: str):
         """Internal helper to safely delete a file."""
         try:
             if os.path.exists(file_path):

{iris_devtester-1.19.2 → iris_devtester-1.19.3}/iris_devtester/containers/iris_container.py

@@ -350,7 +350,7 @@ class IRISContainer(IRISBase):
         return container
 
     @classmethod
-    def attach(cls, container_name: str, **kwargs) -> "IRISContainer":
+    def attach(cls, container_name: str, port: Optional[int] = None, **kwargs) -> "IRISContainer":
         """
         Attach to an existing IRIS container by name.
 
@@ -360,18 +360,43 @@ class IRISContainer(IRISBase):
 
         Args:
             container_name: Name of the existing Docker container.
+            port: Host-side SuperServer port to use instead of the Docker-inspected
+                binding. Required when Docker Desktop NAT rewrites the source IP and
+                IRIS rejects the connection (macOS Docker Desktop with irishealth
+                enterprise). When supplied, the docker port lookup is skipped entirely.
+                Also honoured via ``IVG_PORT`` or ``IRIS_PORT`` environment variables
+                when ``port`` is not provided explicitly.
             **kwargs: Additional configuration (username, password, namespace).
 
         Returns:
             An IRISContainer instance attached to the existing container.
         """
+        import os
+
         if not container_name:
             raise ValueError("container_name must be a non-empty string")
 
+        # Resolve explicit port override: parameter > IVG_PORT > IRIS_PORT
+        if port is None:
+            for env_var in ("IVG_PORT", "IRIS_PORT"):
+                env_val = os.environ.get(env_var)
+                if env_val:
+                    try:
+                        port = int(env_val)
+                    except ValueError:
+                        pass
+                    else:
+                        break
+
         instance = cls(image="", name=container_name, **kwargs)
         instance._is_attached = True
         instance._container_name = container_name
 
+        # Pin the mapped port immediately so get_mapped_port(1972) never falls
+        # through to the docker port lookup, regardless of which code path below runs.
+        if port is not None:
+            instance._mapped_port = port
+
         try:
             import docker
 
@@ -379,15 +404,16 @@ class IRISContainer(IRISBase):
             container = client.containers.get(container_name)
             instance._container = container
 
-            # If it's a mock container, we need to set these manually
             if not HAS_TESTCONTAINERS:
                 instance.host = "localhost"
-                # Try to find port from container ports
-                ports = container.attrs.get("NetworkSettings", {}).get("Ports", {})
-                if "1972/tcp" in ports and ports["1972/tcp"]:
-                    instance._mapped_port = int(ports["1972/tcp"][0]["HostPort"])
+                # Only read docker port binding when no explicit port was given
+                if port is None:
+                    ports = container.attrs.get("NetworkSettings", {}).get("Ports", {})
+                    if "1972/tcp" in ports and ports["1972/tcp"]:
+                        instance._mapped_port = int(ports["1972/tcp"][0]["HostPort"])
             else:
-                # testcontainers will handle discovery via get_config()
+                # testcontainers will handle host/port discovery via get_config(),
+                # but _mapped_port is already pinned above if port was supplied.
                 instance.get_config()
 
         except Exception as e:

{iris_devtester-1.19.2 → iris_devtester-1.19.3/iris_devtester.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-devtester
-Version: 1.19.2
+Version: 1.19.3
 Summary: Battle-tested InterSystems IRIS infrastructure utilities for Python development
 Author-email: InterSystems Community <community@intersystems.com>
 Maintainer-email: Thomas Dyar <thomas.dyar@intersystems.com>

{iris_devtester-1.19.2 → iris_devtester-1.19.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "iris-devtester"
-version = "1.19.2"
+version = "1.19.3"
 description = "Battle-tested InterSystems IRIS infrastructure utilities for Python development"
 readme = "README.md"
 requires-python = ">=3.9"

{iris_devtester-1.19.2 → iris_devtester-1.19.3}/tests/unit/test_cpf_manager.py

@@ -36,5 +36,7 @@ def test_temp_cpf_cleanup_on_garbage_collection():
 
     gc.collect()
 
-    if os.path.exists(file_path):
-        os.unlink(file_path)
+    # If __del__ cleanup is broken, the file survives — assert before any manual fallback
+    assert not os.path.exists(file_path), (
+        f"TempCPFManager.__del__ did not clean up {file_path} after GC"
+    )

{iris_devtester-1.19.2 → iris_devtester-1.19.3}/tests/unit/test_iris_container.py

@@ -80,14 +80,13 @@ class TestIRISContainer:
         """Test that get_connection() method exists."""
         from iris_devtester.containers import IRISContainer
 
-        # Check that class has this method
-        assert hasattr(IRISContainer, "get_connection") or "get_connection" in dir(IRISContainer)
+        assert hasattr(IRISContainer, "get_connection") and callable(IRISContainer.get_connection)
 
     def test_wait_for_ready_method_exists(self):
         """Test that wait_for_ready() method exists."""
         from iris_devtester.containers import IRISContainer
 
-        assert hasattr(IRISContainer, "wait_for_ready") or "wait_for_ready" in dir(IRISContainer)
+        assert hasattr(IRISContainer, "wait_for_ready") and callable(IRISContainer.wait_for_ready)
 
     def test_with_preconfigured_password_method_exists(self):
         """Test that with_preconfigured_password() method exists for password pre-configuration."""
@@ -107,22 +106,12 @@ class TestIRISContainer:
         """Test that get_config() method returns IRISConfig."""
         from iris_devtester.containers import IRISContainer
 
-        # Should have method to get config
-        assert hasattr(IRISContainer, "get_config") or "get_config" in dir(IRISContainer)
+        assert hasattr(IRISContainer, "get_config") and callable(IRISContainer.get_config)
 
 
 class TestIRISContainerIntegration:
     """Test IRIS container integration with other components."""
 
-    @patch("iris_devtester.containers.iris_container.get_connection")
-    def test_get_connection_uses_connection_manager(self, mock_get_connection):
-        """Test that get_connection() integrates with connection manager."""
-        from iris_devtester.containers import IRISContainer
-
-        # This tests integration - actual implementation will vary
-        # The key is that IRISContainer should use the connection manager
-        assert mock_get_connection is not None
-
     def test_password_preconfig_sets_env_vars(self):
         """Test that password pre-configuration works via env vars."""
         from iris_devtester.containers import IRISContainer
@@ -135,25 +124,89 @@ class TestIRISContainerIntegration:
         assert container._preconfigure_password == "TestPass123"
         assert container._password == "TestPass123"
 
-    def test_container_provides_connection_info(self):
-        """Test that container can provide connection information."""
+class TestAttachPortOverride:
+    """attach(port=) must skip docker port lookup and use the supplied port directly."""
+
+    def _make_mock_container(self, host_port: int = 31972):
+        """Return a mock Docker container whose port binding reports host_port."""
+        mock_container = MagicMock()
+        mock_container.attrs = {
+            "NetworkSettings": {
+                "Ports": {"1972/tcp": [{"HostPort": str(host_port)}]},
+                "Networks": {},
+            }
+        }
+        mock_container.name = "ivg-iris-enterprise"
+        # get_container_host_ip() is called by get_config() in the testcontainers path
+        mock_container.get_container_host_ip = MagicMock(return_value="localhost")
+        mock_container.get_exposed_port = MagicMock(return_value=host_port)
+        return mock_container
+
+    @patch("iris_devtester.containers.iris_container.IRISContainer.get_config")
+    @patch("docker.from_env")
+    def test_explicit_port_skips_docker_lookup(self, mock_docker, mock_get_config):
+        """When port= is supplied, _mapped_port must equal that port, not the docker binding."""
         from iris_devtester.containers import IRISContainer
 
-        # Container should be able to provide host, port, namespace
-        # This might be via get_config() or individual methods
-        assert IRISContainer is not None
+        mock_client = MagicMock()
+        mock_docker.return_value = mock_client
+        mock_client.containers.get.return_value = self._make_mock_container(host_port=31972)
 
+        iris = IRISContainer.attach("ivg-iris-enterprise", port=31971)
 
-class TestIRISContainerConfiguration:
-    """Test IRIS container configuration options."""
+        assert iris._mapped_port == 31971, (
+            f"Expected _mapped_port=31971 (explicit), got {iris._mapped_port}"
+        )
 
-    def test_community_accepts_namespace_parameter(self):
-        """Test that community() accepts namespace parameter."""
+    @patch("iris_devtester.containers.iris_container.IRISContainer.get_config")
+    @patch("docker.from_env")
+    def test_explicit_port_used_by_get_mapped_port(self, mock_docker, mock_get_config):
+        """get_mapped_port(1972) must return the explicit port, not the docker-inspected one."""
         from iris_devtester.containers import IRISContainer
 
-        # Should accept namespace in some form
-        # (might be via .with_namespace() or direct parameter)
-        assert IRISContainer.community is not None
+        mock_client = MagicMock()
+        mock_docker.return_value = mock_client
+        mock_client.containers.get.return_value = self._make_mock_container(host_port=31972)
+
+        iris = IRISContainer.attach("ivg-iris-enterprise", port=31971)
+
+        assert iris.get_mapped_port(1972) == 31971
+
+    @patch("iris_devtester.containers.iris_container.IRISContainer.get_config")
+    @patch("docker.from_env")
+    def test_without_port_does_not_pin_mapped_port(self, mock_docker, mock_get_config):
+        """Without port=, _mapped_port is not pinned by attach() — port discovery deferred to get_config()."""
+        from iris_devtester.containers import IRISContainer
+
+        mock_client = MagicMock()
+        mock_docker.return_value = mock_client
+        mock_client.containers.get.return_value = self._make_mock_container(host_port=31972)
+
+        iris = IRISContainer.attach("ivg-iris-enterprise")
+
+        # No explicit port: _mapped_port is not set by attach itself (get_config handles discovery)
+        assert iris._mapped_port is None
+
+    @patch.dict("os.environ", {"IVG_PORT": "31971"})
+    @patch("iris_devtester.containers.iris_container.IRISContainer.get_config")
+    @patch("docker.from_env")
+    def test_ivg_port_env_var_respected(self, mock_docker, mock_get_config):
+        """IVG_PORT env var must be honoured as a port override in attach()."""
+        from iris_devtester.containers import IRISContainer
+
+        mock_client = MagicMock()
+        mock_docker.return_value = mock_client
+        mock_client.containers.get.return_value = self._make_mock_container(host_port=31972)
+
+        iris = IRISContainer.attach("ivg-iris-enterprise")
+
+        assert iris._mapped_port == 31971, (
+            f"IVG_PORT=31971 should override docker binding 31972, got {iris._mapped_port}"
+        )
+
+
+class TestIRISContainerConfiguration:
+    """Test IRIS container configuration options."""
 
     def test_enterprise_requires_license_key(self):
         """Test that enterprise() raises error without license key."""
@@ -174,14 +227,5 @@ class TestIRISContainerConfiguration:
         with pytest.raises(ValueError, match="License key file not found"):
             IRISContainer.enterprise(license_key="/nonexistent/path/iris.key")
 
-    def test_container_supports_custom_image(self):
-        """Test that container supports custom IRIS images."""
-        from iris_devtester.containers import IRISContainer
-
-        # Should be able to specify custom image
-        # (implementation may use .with_image() or similar)
-        assert IRISContainer is not None
-
-
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])

{iris_devtester-1.19.2 → iris_devtester-1.19.3}/tests/unit/test_wait_strategies.py

@@ -42,15 +42,6 @@ class TestIRISReadyWaitStrategy:
         # Should have method to check IRIS process
         assert hasattr(strategy, "check_iris_running") or hasattr(strategy, "wait_until_ready")
 
-    def test_wait_strategy_checks_database_ready(self):
-        """Test that wait strategy verifies database accepts queries."""
-        from iris_devtester.containers.wait_strategies import IRISReadyWaitStrategy
-
-        strategy = IRISReadyWaitStrategy()
-
-        # Should be able to test database readiness
-        assert strategy is not None
-
     def test_wait_strategy_timeout(self):
         """Test that wait strategy respects timeout."""
         from iris_devtester.containers.wait_strategies import IRISReadyWaitStrategy
@@ -60,29 +51,6 @@ class TestIRISReadyWaitStrategy:
         # Should have timeout attribute
         assert hasattr(strategy, "timeout") or hasattr(strategy, "_timeout")
 
-    @patch("time.time")
-    def test_wait_strategy_timeout_raises(self, mock_time):
-        """Test that wait strategy raises on timeout."""
-        from iris_devtester.containers.wait_strategies import IRISReadyWaitStrategy
-
-        # Mock time to simulate timeout
-        mock_time.side_effect = [0, 0, 100]  # Start, check, timeout
-
-        strategy = IRISReadyWaitStrategy(timeout=1)
-
-        # Should implement timeout logic
-        assert strategy is not None
-
-    def test_wait_strategy_default_timeout(self):
-        """Test that wait strategy has reasonable default timeout."""
-        from iris_devtester.containers.wait_strategies import IRISReadyWaitStrategy
-
-        strategy = IRISReadyWaitStrategy()
-
-        # Should have a timeout (either attribute or parameter)
-        assert strategy is not None
-
-
 class TestWaitForIRISReady:
     """Test convenience function for waiting for IRIS."""
 
@@ -103,8 +71,7 @@ class TestWaitForIRISReady:
 
         result = wait_for_iris_ready(host="localhost", port=1972, timeout=1)
 
-        # Should attempt to connect to port
-        assert isinstance(result, bool) or result is None
+        assert isinstance(result, bool), f"wait_for_iris_ready must return bool, got {type(result)}"
 
     def test_wait_function_with_timeout(self):
         """Test wait function respects timeout parameter."""

{iris_devtester-1.19.2 → iris_devtester-1.19.3}/tests/unit/utils/test_dbapi_compat.py

@@ -108,7 +108,7 @@ class TestSingletonPoisoning:
             assert not isinstance(info_after.connect_function, MagicMock), (
                 "Singleton poisoning: connect_function is still a MagicMock after patch exited"
             )
-        except Exception:
+        except (ImportError, dc.DBAPIPackageNotFoundError):
             # Package not installed in test env — that's fine, not the bug we're testing
             pass