proximl 0.5.16__py3-none-any.whl → 1.0.0__py3-none-any.whl

tests/unit/cli/test_cli_checkpoint_unit.py

@@ -1,15 +1,24 @@
 import re
 import json
 import click
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock, patch, Mock
 from pytest import mark, fixture, raises
 
 pytestmark = [mark.cli, mark.unit, mark.checkpoints]
 
 from proximl.cli import checkpoint as specimen
+from proximl.cli.checkpoint import pretty_size
 from proximl.checkpoints import Checkpoint
 
 
+def test_pretty_size_zero():
+    """Test pretty_size with zero/None (line 7)."""
+    result = pretty_size(None)
+    assert result == "0.00   B"
+    result = pretty_size(0)
+    assert result == "0.00   B"
+
+
 def test_list(runner, mock_my_checkpoints):
     with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
         mock_proximl.checkpoints = AsyncMock()
@@ -20,3 +29,305 @@ def test_list(runner, mock_my_checkpoints):
         print(result)
         assert result.exit_code == 0
         mock_proximl.checkpoints.list.assert_called_once()
+
+
+def test_attach_success(runner, mock_my_checkpoints):
+    """Test attach command success (lines 32-38)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+
+        async def list_async():
+            return mock_my_checkpoints
+
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.list = Mock(side_effect=lambda: list_async())
+
+        # Use the first checkpoint from the list
+        checkpoint = mock_my_checkpoints[0]
+
+        async def attach_async():
+            return None
+
+        checkpoint.attach = Mock(return_value=attach_async())
+
+        with patch("proximl.cli.search_by_id_name", return_value=checkpoint):
+            result = runner.invoke(specimen, ["attach", "1"])
+            assert result.exit_code == 0
+            checkpoint.attach.assert_called_once()
+
+
+def test_attach_not_found(runner, mock_my_checkpoints):
+    """Test attach command when checkpoint not found (line 36)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+
+        async def list_async():
+            return mock_my_checkpoints
+
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.list = Mock(side_effect=lambda: list_async())
+
+        with patch("proximl.cli.search_by_id_name", return_value=None):
+            result = runner.invoke(specimen, ["attach", "nonexistent"])
+            assert result.exit_code != 0
+            assert "Cannot find specified checkpoint" in result.output
+
+
+def test_connect_with_attach(runner, mock_my_checkpoints):
+    """Test connect command with attach (lines 56-65, attach=True)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+
+        async def list_async():
+            return mock_my_checkpoints
+
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.list = Mock(side_effect=lambda: list_async())
+
+        checkpoint = mock_my_checkpoints[0]
+
+        async def connect_async():
+            return None
+
+        async def attach_async():
+            return None
+
+        checkpoint.connect = Mock(return_value=connect_async())
+        checkpoint.attach = Mock(return_value=attach_async())
+
+        with patch("proximl.cli.search_by_id_name", return_value=checkpoint):
+            result = runner.invoke(specimen, ["connect", "1"])
+            assert result.exit_code == 0
+            checkpoint.connect.assert_called_once()
+            checkpoint.attach.assert_called_once()
+
+
+def test_connect_no_attach(runner, mock_my_checkpoints):
+    """Test connect command without attach (lines 56-65, attach=False)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+
+        async def list_async():
+            return mock_my_checkpoints
+
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.list = Mock(side_effect=lambda: list_async())
+
+        checkpoint = mock_my_checkpoints[0]
+
+        async def connect_async():
+            return None
+
+        checkpoint.connect = Mock(return_value=connect_async())
+
+        with patch("proximl.cli.search_by_id_name", return_value=checkpoint):
+            result = runner.invoke(specimen, ["connect", "--no-attach", "1"])
+            assert result.exit_code == 0
+            checkpoint.connect.assert_called_once()
+
+
+def test_connect_not_found(runner, mock_my_checkpoints):
+    """Test connect command when checkpoint not found (line 60)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+
+        async def list_async():
+            return mock_my_checkpoints
+
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.list = Mock(side_effect=lambda: list_async())
+
+        with patch("proximl.cli.search_by_id_name", return_value=None):
+            result = runner.invoke(specimen, ["connect", "nonexistent"])
+            assert result.exit_code != 0
+            assert "Cannot find specified checkpoint" in result.output
+
+
+def test_create_with_connect_and_attach(runner, tmp_path, mock_my_checkpoints):
+    """Test create command with connect and attach (lines 103-115)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+        checkpoint = mock_my_checkpoints[0]
+
+        async def connect_async():
+            return None
+
+        async def attach_async():
+            return None
+
+        checkpoint.connect = Mock(return_value=connect_async())
+        checkpoint.attach = Mock(return_value=attach_async())
+
+        async def create_async(**kwargs):
+            return checkpoint
+
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.create = Mock(
+            side_effect=lambda **kwargs: create_async(**kwargs)
+        )
+
+        test_dir = tmp_path / "test_checkpoint"
+        test_dir.mkdir()
+        result = runner.invoke(
+            specimen, ["create", "test-checkpoint", str(test_dir)]
+        )
+        assert result.exit_code == 0
+        mock_proximl.checkpoints.create.assert_called_once()
+        checkpoint.connect.assert_called_once()
+        checkpoint.attach.assert_called_once()
+
+
+def test_create_with_connect_no_attach(runner, tmp_path, mock_my_checkpoints):
+    """Test create command with connect but no attach (lines 103-115)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+        checkpoint = mock_my_checkpoints[0]
+
+        async def connect_async():
+            return None
+
+        checkpoint.connect = Mock(return_value=connect_async())
+
+        async def create_async(**kwargs):
+            return checkpoint
+
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.create = Mock(
+            side_effect=lambda **kwargs: create_async(**kwargs)
+        )
+
+        test_dir = tmp_path / "test_checkpoint"
+        test_dir.mkdir()
+        result = runner.invoke(
+            specimen,
+            ["create", "--no-attach", "test-checkpoint", str(test_dir)],
+        )
+        assert result.exit_code == 0
+        checkpoint.connect.assert_called_once()
+
+
+def test_create_no_connect(runner, tmp_path):
+    """Test create command without connect (lines 103-115, line 115)."""
+    mock_checkpoint = Mock(spec=Checkpoint)
+
+    mock_proximl_runner = Mock()
+    mock_proximl_runner.client = Mock()
+    mock_proximl_runner.client.checkpoints = Mock()
+    mock_proximl_runner.client.checkpoints.create = AsyncMock(
+        return_value=mock_checkpoint
+    )
+    mock_proximl_runner.run = Mock(
+        side_effect=lambda x: x if not hasattr(x, "__call__") else x()
+    )
+
+    with patch("proximl.cli.ProxiMLRunner", return_value=mock_proximl_runner):
+        test_dir = tmp_path / "test_checkpoint"
+        test_dir.mkdir()
+        result = runner.invoke(
+            specimen,
+            ["create", "--no-connect", "test-checkpoint", str(test_dir)],
+        )
+        assert result.exit_code != 0
+        assert "No logs to show" in result.output
+
+
+def test_list_public(runner, mock_my_checkpoints):
+    """Test list_public command (lines 152-171)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.list_public = AsyncMock(
+            return_value=mock_my_checkpoints
+        )
+
+        result = runner.invoke(specimen, ["list-public"])
+        assert result.exit_code == 0
+        mock_proximl.checkpoints.list_public.assert_called_once()
+
+
+def test_remove_success(runner, mock_my_checkpoints):
+    """Test remove command success (lines 192-201)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+
+        async def list_async():
+            return mock_my_checkpoints
+
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.list = Mock(side_effect=lambda: list_async())
+
+        checkpoint = mock_my_checkpoints[0]
+
+        async def remove_async():
+            return None
+
+        checkpoint.remove = Mock(return_value=remove_async())
+
+        with patch("proximl.cli.search_by_id_name", return_value=checkpoint):
+            result = runner.invoke(specimen, ["remove", "1"])
+            assert result.exit_code == 0
+            checkpoint.remove.assert_called_once_with(force=False)
+
+
+def test_remove_not_found(runner, mock_my_checkpoints):
+    """Test remove command when checkpoint not found (lines 192-201)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+
+        async def list_async():
+            return mock_my_checkpoints
+
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.list = Mock(side_effect=lambda: list_async())
+
+        with patch("proximl.cli.search_by_id_name", return_value=None):
+            result = runner.invoke(specimen, ["remove", "nonexistent"])
+            assert result.exit_code != 0
+            assert "Cannot find specified checkpoint" in result.output
+
+
+def test_rename_success(runner, mock_my_checkpoints):
+    """Test rename command success (lines 214-223)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+        checkpoint = mock_my_checkpoints[0]
+
+        async def rename_async():
+            return None
+
+        checkpoint.rename = Mock(return_value=rename_async())
+
+        async def get_async(checkpoint_id):
+            return checkpoint
+
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.get = Mock(
+            side_effect=lambda checkpoint_id: get_async(checkpoint_id)
+        )
+
+        result = runner.invoke(specimen, ["rename", "1", "new-name"])
+        assert result.exit_code == 0
+        checkpoint.rename.assert_called_once_with(name="new-name")
+
+
+def test_rename_not_found_none(runner):
+    """Test rename command when checkpoint is None (lines 214-223, line 219)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+
+        async def get_async(checkpoint_id):
+            return None
+
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.get = Mock(
+            side_effect=lambda checkpoint_id: get_async(checkpoint_id)
+        )
+
+        result = runner.invoke(specimen, ["rename", "nonexistent", "new-name"])
+        assert result.exit_code != 0
+        assert "Cannot find specified checkpoint" in result.output
+
+
+def test_rename_not_found_exception(runner):
+    """Test rename command when exception occurs (lines 214-223, line 221)."""
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+
+        async def get_async(checkpoint_id):
+            raise Exception("Not found")
+
+        mock_proximl.checkpoints = AsyncMock()
+        mock_proximl.checkpoints.get = Mock(
+            side_effect=lambda checkpoint_id: get_async(checkpoint_id)
+        )
+
+        result = runner.invoke(specimen, ["rename", "nonexistent", "new-name"])
+        assert result.exit_code != 0
+        assert "Cannot find specified checkpoint" in result.output

tests/unit/cloudbender/test_nodes_unit.py

@@ -8,6 +8,7 @@ from aiohttp import WSMessage, WSMsgType
 import proximl.cloudbender.nodes as specimen
 from proximl.exceptions import (
     ApiError,
+    NodeError,
     SpecificationError,
     ProxiMLException,
 )
@@ -200,3 +201,114 @@ class nodeTests:
             None,
             dict(command="report"),
         )
+
+    @mark.asyncio
+    async def test_node_wait_for_already_at_status(self, node):
+        """Test wait_for returns immediately if already at target status."""
+        node._status = "active"
+        result = await node.wait_for("active")
+        assert result is None
+
+    @mark.asyncio
+    async def test_node_wait_for_invalid_status(self, node):
+        """Test wait_for raises error for invalid status."""
+        with raises(SpecificationError) as exc_info:
+            await node.wait_for("invalid_status")
+        assert "Invalid wait_for status" in str(exc_info.value.message)
+
+    @mark.asyncio
+    async def test_node_wait_for_timeout_validation(self, node):
+        """Test wait_for validates timeout (line 172)."""
+        node._status = "new"  # Set to different status so timeout check runs
+        with raises(SpecificationError) as exc_info:
+            await node.wait_for("active", timeout=25 * 60 * 60)
+        assert "timeout must be less than" in str(exc_info.value.message)
+
+    @mark.asyncio
+    async def test_node_wait_for_success(self, node, mock_proximl):
+        """Test wait_for succeeds when status matches."""
+        node._status = "new"
+        api_response_new = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            rig_uuid="x",
+            status="new",
+        )
+        api_response_active = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            rig_uuid="x",
+            status="active",
+        )
+        mock_proximl._query = AsyncMock(
+            side_effect=[api_response_new, api_response_active]
+        )
+        with patch("proximl.cloudbender.nodes.asyncio.sleep", new_callable=AsyncMock):
+            result = await node.wait_for("active", timeout=10)
+        assert result == node
+        assert node.status == "active"
+
+    @mark.asyncio
+    async def test_node_wait_for_archived_404(self, node, mock_proximl):
+        """Test wait_for handles 404 for archived status."""
+        node._status = "active"
+        api_error = ApiError(404, {"errorMessage": "Not found"})
+        mock_proximl._query = AsyncMock(side_effect=api_error)
+        with patch("proximl.cloudbender.nodes.asyncio.sleep", new_callable=AsyncMock):
+            await node.wait_for("archived", timeout=10)
+
+    @mark.asyncio
+    async def test_node_wait_for_error_status(self, node, mock_proximl):
+        """Test wait_for raises error for errored/failed status."""
+        node._status = "new"
+        api_response_errored = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            rig_uuid="x",
+            status="errored",
+        )
+        mock_proximl._query = AsyncMock(return_value=api_response_errored)
+        with patch("proximl.cloudbender.nodes.asyncio.sleep", new_callable=AsyncMock):
+            with raises(NodeError):
+                await node.wait_for("active", timeout=10)
+
+    @mark.asyncio
+    async def test_node_wait_for_timeout(self, node, mock_proximl):
+        """Test wait_for raises timeout exception."""
+        node._status = "new"
+        api_response_new = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            rig_uuid="x",
+            status="new",
+        )
+        mock_proximl._query = AsyncMock(return_value=api_response_new)
+        with patch("proximl.cloudbender.nodes.asyncio.sleep", new_callable=AsyncMock):
+            with raises(ProxiMLException) as exc_info:
+                await node.wait_for("active", timeout=0.1)
+        assert "Timeout waiting for" in str(exc_info.value.message)
+
+    @mark.asyncio
+    async def test_node_wait_for_api_error_non_404(self, node, mock_proximl):
+        """Test wait_for raises ApiError when not 404 for archived (line 189)."""
+        node._status = "active"
+        api_error = ApiError(500, {"errorMessage": "Server Error"})
+        mock_proximl._query = AsyncMock(side_effect=api_error)
+        with patch("proximl.cloudbender.nodes.asyncio.sleep", new_callable=AsyncMock):
+            with raises(ApiError):
+                await node.wait_for("archived", timeout=10)
+
+    @mark.asyncio
+    async def test_node_wait_for_failed_status(self, node, mock_proximl):
+        """Test wait_for raises error for failed status (line 191)."""
+        node._status = "new"
+        api_response_failed = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            rig_uuid="x",
+            status="failed",
+        )
+        mock_proximl._query = AsyncMock(return_value=api_response_failed)
+        with patch("proximl.cloudbender.nodes.asyncio.sleep", new_callable=AsyncMock):
+            with raises(NodeError):
+                await node.wait_for("active", timeout=10)

tests/unit/cloudbender/test_providers_unit.py

@@ -139,3 +139,99 @@ class providerTests:
         mock_proximl._query.assert_called_once_with(f"/provider/1", "GET")
         assert provider.id == "provider-id-1"
         assert response.id == "provider-id-1"
+
+    def test_provider_status_property(self, provider):
+        """Test provider status property."""
+        provider._status = "ready"
+        assert provider.status == "ready"
+
+    @mark.asyncio
+    async def test_provider_wait_for_already_at_status(self, provider):
+        """Test wait_for returns immediately if already at target status."""
+        provider._status = "ready"
+        result = await provider.wait_for("ready")
+        assert result is None
+
+    @mark.asyncio
+    async def test_provider_wait_for_invalid_status(self, provider):
+        """Test wait_for raises error for invalid status."""
+        with raises(SpecificationError) as exc_info:
+            await provider.wait_for("invalid_status")
+        assert "Invalid wait_for status" in str(exc_info.value.message)
+
+    @mark.asyncio
+    async def test_provider_wait_for_timeout_validation(self, provider):
+        """Test wait_for validates timeout."""
+        with raises(SpecificationError) as exc_info:
+            await provider.wait_for("ready", timeout=25 * 60 * 60)
+        assert "timeout must be less than" in str(exc_info.value.message)
+
+    @mark.asyncio
+    async def test_provider_wait_for_success(self, provider, mock_proximl):
+        """Test wait_for succeeds when status matches."""
+        provider._status = "new"
+        api_response_new = dict(
+            customer_uuid="a",
+            provider_uuid="1",
+            status="new",
+        )
+        api_response_ready = dict(
+            customer_uuid="a",
+            provider_uuid="1",
+            status="ready",
+        )
+        mock_proximl._query = AsyncMock(
+            side_effect=[api_response_new, api_response_ready]
+        )
+        with patch("proximl.cloudbender.providers.asyncio.sleep", new_callable=AsyncMock):
+            result = await provider.wait_for("ready", timeout=10)
+        assert result == provider
+        assert provider.status == "ready"
+
+    @mark.asyncio
+    async def test_provider_wait_for_archived_404(self, provider, mock_proximl):
+        """Test wait_for handles 404 for archived status."""
+        provider._status = "ready"
+        api_error = ApiError(404, {"errorMessage": "Not found"})
+        mock_proximl._query = AsyncMock(side_effect=api_error)
+        with patch("proximl.cloudbender.providers.asyncio.sleep", new_callable=AsyncMock):
+            await provider.wait_for("archived", timeout=10)
+
+    @mark.asyncio
+    async def test_provider_wait_for_error_status(self, provider, mock_proximl):
+        """Test wait_for raises error for errored/failed status."""
+        provider._status = "new"
+        api_response_errored = dict(
+            customer_uuid="a",
+            provider_uuid="1",
+            status="errored",
+        )
+        mock_proximl._query = AsyncMock(return_value=api_response_errored)
+        with patch("proximl.cloudbender.providers.asyncio.sleep", new_callable=AsyncMock):
+            with raises(specimen.ProviderError):
+                await provider.wait_for("ready", timeout=10)
+
+    @mark.asyncio
+    async def test_provider_wait_for_timeout(self, provider, mock_proximl):
+        """Test wait_for raises timeout exception."""
+        provider._status = "new"
+        api_response_new = dict(
+            customer_uuid="a",
+            provider_uuid="1",
+            status="new",
+        )
+        mock_proximl._query = AsyncMock(return_value=api_response_new)
+        with patch("proximl.cloudbender.providers.asyncio.sleep", new_callable=AsyncMock):
+            with raises(ProxiMLException) as exc_info:
+                await provider.wait_for("ready", timeout=0.1)
+        assert "Timeout waiting for" in str(exc_info.value.message)
+
+    @mark.asyncio
+    async def test_provider_wait_for_api_error_non_404(self, provider, mock_proximl):
+        """Test wait_for raises ApiError when not 404 for archived (line 115)."""
+        provider._status = "ready"
+        api_error = ApiError(500, {"errorMessage": "Server Error"})
+        mock_proximl._query = AsyncMock(side_effect=api_error)
+        with patch("proximl.cloudbender.providers.asyncio.sleep", new_callable=AsyncMock):
+            with raises(ApiError):
+                await provider.wait_for("archived", timeout=10)

tests/unit/cloudbender/test_regions_unit.py

@@ -195,3 +195,109 @@ class regionTests:
         mock_proximl._query.assert_called_once_with(
             "/provider/1/region/a/checkpoint", "POST", None, expected_payload
         )
+
+    @mark.asyncio
+    async def test_region_wait_for_already_at_status(self, region):
+        """Test wait_for returns immediately if already at target status."""
+        region._status = "healthy"
+        result = await region.wait_for("healthy")
+        assert result is None
+
+    @mark.asyncio
+    async def test_region_wait_for_invalid_status(self, region):
+        """Test wait_for raises error for invalid status."""
+        with raises(SpecificationError) as exc_info:
+            await region.wait_for("invalid_status")
+        assert "Invalid wait_for status" in str(exc_info.value.message)
+
+    @mark.asyncio
+    async def test_region_wait_for_timeout_validation(self, region):
+        """Test wait_for validates timeout (line 135)."""
+        region._status = "new"  # Set to different status so timeout check runs
+        with raises(SpecificationError) as exc_info:
+            await region.wait_for("healthy", timeout=25 * 60 * 60)
+        assert "timeout must be less than" in str(exc_info.value.message)
+
+    @mark.asyncio
+    async def test_region_wait_for_success(self, region, mock_proximl):
+        """Test wait_for succeeds when status matches."""
+        region._status = "new"
+        api_response_new = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            status="new",
+        )
+        api_response_healthy = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            status="healthy",
+        )
+        mock_proximl._query = AsyncMock(
+            side_effect=[api_response_new, api_response_healthy]
+        )
+        with patch("proximl.cloudbender.regions.asyncio.sleep", new_callable=AsyncMock):
+            result = await region.wait_for("healthy", timeout=10)
+        assert result == region
+        assert region.status == "healthy"
+
+    @mark.asyncio
+    async def test_region_wait_for_archived_404(self, region, mock_proximl):
+        """Test wait_for handles 404 for archived status."""
+        region._status = "healthy"
+        api_error = ApiError(404, {"errorMessage": "Not found"})
+        mock_proximl._query = AsyncMock(side_effect=api_error)
+        with patch("proximl.cloudbender.regions.asyncio.sleep", new_callable=AsyncMock):
+            await region.wait_for("archived", timeout=10)
+
+    @mark.asyncio
+    async def test_region_wait_for_error_status(self, region, mock_proximl):
+        """Test wait_for raises error for errored/failed status."""
+        region._status = "new"
+        api_response_errored = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            status="errored",
+        )
+        mock_proximl._query = AsyncMock(return_value=api_response_errored)
+        with patch("proximl.cloudbender.regions.asyncio.sleep", new_callable=AsyncMock):
+            with raises(specimen.RegionError):
+                await region.wait_for("healthy", timeout=10)
+
+    @mark.asyncio
+    async def test_region_wait_for_timeout(self, region, mock_proximl):
+        """Test wait_for raises timeout exception."""
+        region._status = "new"
+        api_response_new = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            status="new",
+        )
+        mock_proximl._query = AsyncMock(return_value=api_response_new)
+        with patch("proximl.cloudbender.regions.asyncio.sleep", new_callable=AsyncMock):
+            with raises(ProxiMLException) as exc_info:
+                await region.wait_for("healthy", timeout=0.1)
+        assert "Timeout waiting for" in str(exc_info.value.message)
+
+    @mark.asyncio
+    async def test_region_wait_for_api_error_non_404(self, region, mock_proximl):
+        """Test wait_for raises ApiError when not 404 for archived (line 152)."""
+        region._status = "healthy"
+        api_error = ApiError(500, {"errorMessage": "Server Error"})
+        mock_proximl._query = AsyncMock(side_effect=api_error)
+        with patch("proximl.cloudbender.regions.asyncio.sleep", new_callable=AsyncMock):
+            with raises(ApiError):
+                await region.wait_for("archived", timeout=10)
+
+    @mark.asyncio
+    async def test_region_wait_for_failed_status(self, region, mock_proximl):
+        """Test wait_for raises error for failed status."""
+        region._status = "new"
+        api_response_failed = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            status="failed",
+        )
+        mock_proximl._query = AsyncMock(return_value=api_response_failed)
+        with patch("proximl.cloudbender.regions.asyncio.sleep", new_callable=AsyncMock):
+            with raises(specimen.RegionError):
+                await region.wait_for("healthy", timeout=10)