proximl 0.5.17__py3-none-any.whl → 1.0.1__py3-none-any.whl

tests/unit/cloudbender/test_services_unit.py

@@ -165,3 +165,144 @@ class serviceTests:
         )
         assert service.id == "service-id-1"
         assert response.id == "service-id-1"
+
+    def test_service_status_property(self, service):
+        """Test service status property."""
+        service._status = "active"
+        assert service.status == "active"
+
+    def test_service_port_property(self, service):
+        """Test service port property."""
+        service._port = "443"
+        assert service.port == "443"
+
+    @mark.asyncio
+    async def test_service_wait_for_already_at_status(self, service):
+        """Test wait_for returns immediately if already at target status."""
+        service._status = "active"
+        result = await service.wait_for("active")
+        assert result is None
+
+    @mark.asyncio
+    async def test_service_wait_for_invalid_status(self, service):
+        """Test wait_for raises error for invalid status."""
+        with raises(SpecificationError) as exc_info:
+            await service.wait_for("invalid_status")
+        assert "Invalid wait_for status" in str(exc_info.value.message)
+
+    @mark.asyncio
+    async def test_service_wait_for_timeout_validation(self, service):
+        """Test wait_for validates timeout."""
+        with raises(SpecificationError) as exc_info:
+            await service.wait_for("active", timeout=25 * 60 * 60)
+        assert "timeout must be less than" in str(exc_info.value.message)
+
+    @mark.asyncio
+    async def test_service_wait_for_success(self, service, mock_proximl):
+        """Test wait_for succeeds when status matches."""
+        service._status = "new"
+        api_response_new = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            service_id="x",
+            status="new",
+        )
+        api_response_active = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            service_id="x",
+            status="active",
+        )
+        mock_proximl._query = AsyncMock(
+            side_effect=[api_response_new, api_response_active]
+        )
+        with patch("proximl.cloudbender.services.asyncio.sleep", new_callable=AsyncMock):
+            result = await service.wait_for("active", timeout=10)
+        assert result == service
+        assert service.status == "active"
+
+    @mark.asyncio
+    async def test_service_wait_for_archived_404(self, service, mock_proximl):
+        """Test wait_for handles 404 for archived status."""
+        service._status = "active"
+        api_error = ApiError(404, {"errorMessage": "Not found"})
+        mock_proximl._query = AsyncMock(side_effect=api_error)
+        with patch("proximl.cloudbender.services.asyncio.sleep", new_callable=AsyncMock):
+            await service.wait_for("archived", timeout=10)
+
+    @mark.asyncio
+    async def test_service_wait_for_timeout(self, service, mock_proximl):
+        """Test wait_for raises timeout exception."""
+        service._status = "new"
+        api_response_new = dict(
+            provider_uuid="1",
+            region_uuid="a",
+            service_id="x",
+            status="new",
+        )
+        mock_proximl._query = AsyncMock(return_value=api_response_new)
+        with patch("proximl.cloudbender.services.asyncio.sleep", new_callable=AsyncMock):
+            with raises(ProxiMLException) as exc_info:
+                await service.wait_for("active", timeout=0.1)
+        assert "Timeout waiting for" in str(exc_info.value.message)
+
+    @mark.asyncio
+    async def test_service_wait_for_api_error_non_404(self, service, mock_proximl):
+        """Test wait_for raises ApiError when not 404 for archived (line 181)."""
+        service._status = "active"
+        api_error = ApiError(500, {"errorMessage": "Server Error"})
+        mock_proximl._query = AsyncMock(side_effect=api_error)
+        with patch("proximl.cloudbender.services.asyncio.sleep", new_callable=AsyncMock):
+            with raises(ApiError):
+                await service.wait_for("archived", timeout=10)
+
+    @mark.asyncio
+    async def test_service_generate_certificate(self, service, mock_proximl):
+        """Test generate_certificate method."""
+        api_response = {
+            "provider_uuid": "1",
+            "region_uuid": "a",
+            "service_id": "x",
+            "certificate": "cert-data",
+        }
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        result = await service.generate_certificate()
+        mock_proximl._query.assert_called_once_with(
+            "/provider/1/region/a/service/x/certificate",
+            "POST",
+            {},
+            dict(algorithm="ed25519"),
+        )
+        assert result == service
+
+    @mark.asyncio
+    async def test_service_generate_certificate_custom_algorithm(self, service, mock_proximl):
+        """Test generate_certificate with custom algorithm."""
+        api_response = {
+            "provider_uuid": "1",
+            "region_uuid": "a",
+            "service_id": "x",
+            "certificate": "cert-data",
+        }
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        result = await service.generate_certificate(algorithm="rsa")
+        mock_proximl._query.assert_called_once_with(
+            "/provider/1/region/a/service/x/certificate",
+            "POST",
+            {},
+            dict(algorithm="rsa"),
+        )
+
+    @mark.asyncio
+    async def test_service_sign_client_certificate(self, service, mock_proximl):
+        """Test sign_client_certificate method."""
+        api_response = {"certificate": "signed-cert-data"}
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        result = await service.sign_client_certificate("csr-data")
+        mock_proximl._query.assert_called_once_with(
+            "/provider/1/region/a/service/x/certificate/sign",
+            "POST",
+            {},
+            dict(csr="csr-data"),
+        )
+        assert result == api_response

tests/unit/conftest.py

@@ -4,7 +4,7 @@ from pytest import fixture, mark
 from unittest.mock import Mock, AsyncMock, patch, create_autospec
 
 from proximl.proximl import ProxiML
-from proximl.auth import Auth
+from proximl.utils.auth import Auth
 from proximl.datasets import Dataset, Datasets
 from proximl.checkpoints import Checkpoint, Checkpoints
 from proximl.volumes import Volume, Volumes
@@ -12,14 +12,16 @@ from proximl.models import Model, Models
 from proximl.gpu_types import GpuType, GpuTypes
 from proximl.environments import Environment, Environments
 from proximl.jobs import Job, Jobs
-from proximl.connections import Connections
 from proximl.projects import (
     Projects,
     Project,
 )
 from proximl.projects.datastores import ProjectDatastores, ProjectDatastore
 from proximl.projects.services import ProjectServices, ProjectService
-from proximl.projects.data_connectors import ProjectDataConnectors, ProjectDataConnector
+from proximl.projects.data_connectors import (
+    ProjectDataConnectors,
+    ProjectDataConnector,
+)
 from proximl.projects.credentials import ProjectCredentials, ProjectCredential
 from proximl.projects.secrets import ProjectSecrets, ProjectSecret
 
@@ -1130,12 +1132,13 @@ def mock_proximl(
     proximl.gpu_types = create_autospec(GpuTypes)
     proximl.environments = create_autospec(Environments)
     proximl.jobs = create_autospec(Jobs)
-    proximl.connections = create_autospec(Connections)
     proximl.projects = create_autospec(Projects)
     proximl.datasets.list = AsyncMock(return_value=mock_my_datasets)
     proximl.datasets.list_public = AsyncMock(return_value=mock_public_datasets)
     proximl.checkpoints.list = AsyncMock(return_value=mock_my_checkpoints)
-    proximl.checkpoints.list_public = AsyncMock(return_value=mock_public_checkpoints)
+    proximl.checkpoints.list_public = AsyncMock(
+        return_value=mock_public_checkpoints
+    )
     proximl.models.list = AsyncMock(return_value=mock_models)
     proximl.volumes.list = AsyncMock(return_value=mock_my_volumes)
     proximl.gpu_types.list = AsyncMock(return_value=mock_gpu_types)
@@ -1143,17 +1146,25 @@ def mock_proximl(
     proximl.jobs.list = AsyncMock(return_value=mock_jobs)
     proximl.projects.list = AsyncMock(return_value=mock_projects)
     proximl.projects.datastores = create_autospec(ProjectDatastores)
-    proximl.projects.datastores.list = AsyncMock(return_value=mock_project_datastores)
+    proximl.projects.datastores.list = AsyncMock(
+        return_value=mock_project_datastores
+    )
     proximl.projects.services = create_autospec(ProjectServices)
-    proximl.projects.services.list = AsyncMock(return_value=mock_project_services)
+    proximl.projects.services.list = AsyncMock(
+        return_value=mock_project_services
+    )
     proximl.projects.data_connectors = create_autospec(ProjectDataConnectors)
     proximl.projects.data_connectors.list = AsyncMock(
         return_value=mock_project_data_connectors
     )
     proximl.projects.credentials = create_autospec(ProjectCredentials)
-    proximl.projects.credentials.list = AsyncMock(return_value=mock_project_credentials)
+    proximl.projects.credentials.list = AsyncMock(
+        return_value=mock_project_credentials
+    )
     proximl.projects.secrets = create_autospec(ProjectSecrets)
-    proximl.projects.secrets.list = AsyncMock(return_value=mock_project_secrets)
+    proximl.projects.secrets.list = AsyncMock(
+        return_value=mock_project_secrets
+    )
 
     proximl.cloudbender = create_autospec(Cloudbender)
 
@@ -1166,7 +1177,9 @@ def mock_proximl(
     proximl.cloudbender.devices = create_autospec(Devices)
     proximl.cloudbender.devices.list = AsyncMock(return_value=mock_devices)
     proximl.cloudbender.datastores = create_autospec(Datastores)
-    proximl.cloudbender.datastores.list = AsyncMock(return_value=mock_datastores)
+    proximl.cloudbender.datastores.list = AsyncMock(
+        return_value=mock_datastores
+    )
     proximl.cloudbender.services = create_autospec(Services)
     proximl.cloudbender.services.list = AsyncMock(return_value=mock_services)
     proximl.cloudbender.data_connectors = create_autospec(DataConnectors)

tests/unit/projects/test_project_data_connectors_unit.py

@@ -33,6 +33,25 @@ def project_data_connector(mock_proximl):
 
 
 class ProjectDataConnectorsTests:
+    @mark.asyncio
+    async def test_project_data_connectors_get(
+        self, project_data_connectors, mock_proximl
+    ):
+        """Test get method (lines 11-14)."""
+        api_response = {
+            "project_uuid": "proj-id-1",
+            "region_uuid": "reg-id-1",
+            "id": "connector-id-1",
+            "type": "custom",
+            "name": "On-Prem Connection A",
+        }
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        result = await project_data_connectors.get("connector-id-1", param1="value1")
+        mock_proximl._query.assert_called_once_with(
+            "/project/1/data_connectors/connector-id-1", "GET", dict(param1="value1")
+        )
+        assert result.id == "connector-id-1"
+
     @mark.asyncio
     async def test_project_data_connectors_refresh(
         self, project_data_connectors, mock_proximl
@@ -100,3 +119,23 @@ class ProjectDataConnectorTests:
         empty_project_data_connector = specimen.ProjectDataConnector(mock_proximl)
         assert bool(project_data_connector)
         assert not bool(empty_project_data_connector)
+
+    @mark.asyncio
+    async def test_project_data_connector_enable(self, project_data_connector, mock_proximl):
+        """Test enable method (line 72)."""
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await project_data_connector.enable()
+        mock_proximl._query.assert_called_once_with(
+            "/project/proj-id-1/data_connectors/ds-id-1/enable", "PATCH"
+        )
+
+    @mark.asyncio
+    async def test_project_data_connector_disable(self, project_data_connector, mock_proximl):
+        """Test disable method (line 77)."""
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await project_data_connector.disable()
+        mock_proximl._query.assert_called_once_with(
+            "/project/proj-id-1/data_connectors/ds-id-1/disable", "PATCH"
+        )

tests/unit/projects/test_project_datastores_unit.py

@@ -33,6 +33,23 @@ def project_datastore(mock_proximl):
 
 
 class ProjectDatastoresTests:
+    @mark.asyncio
+    async def test_project_datastores_get(self, project_datastores, mock_proximl):
+        """Test get method (lines 11-14)."""
+        api_response = {
+            "project_uuid": "proj-id-1",
+            "region_uuid": "reg-id-1",
+            "id": "store-id-1",
+            "type": "nfs",
+            "name": "On-prem NFS",
+        }
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        result = await project_datastores.get("store-id-1", param1="value1")
+        mock_proximl._query.assert_called_once_with(
+            "/project/1/datastores/store-id-1", "GET", dict(param1="value1")
+        )
+        assert result.id == "store-id-1"
+
     @mark.asyncio
     async def test_project_datastores_refresh(self, project_datastores, mock_proximl):
         api_response = dict()
@@ -94,3 +111,23 @@ class ProjectDatastoreTests:
         empty_project_datastore = specimen.ProjectDatastore(mock_proximl)
         assert bool(project_datastore)
         assert not bool(empty_project_datastore)
+
+    @mark.asyncio
+    async def test_project_datastore_enable(self, project_datastore, mock_proximl):
+        """Test enable method (line 67)."""
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await project_datastore.enable()
+        mock_proximl._query.assert_called_once_with(
+            "/project/proj-id-1/datastores/ds-id-1/enable", "PATCH"
+        )
+
+    @mark.asyncio
+    async def test_project_datastore_disable(self, project_datastore, mock_proximl):
+        """Test disable method (line 72)."""
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await project_datastore.disable()
+        mock_proximl._query.assert_called_once_with(
+            "/project/proj-id-1/datastores/ds-id-1/disable", "PATCH"
+        )

tests/unit/projects/test_project_members_unit.py

@@ -37,6 +37,42 @@ def project_member(mock_proximl):
 
 
 class ProjectMembersTests:
+    @mark.asyncio
+    async def test_project_members_add(self, project_members, mock_proximl):
+        """Test add method (lines 18-31)."""
+        api_response = {
+            "project_uuid": "proj-id-1",
+            "email": "newuser@gmail.com",
+            "owner": False,
+            "job": "all",
+            "dataset": "read",
+            "model": "all",
+            "checkpoint": "read",
+            "volume": "all",
+        }
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        result = await project_members.add(
+            email="newuser@gmail.com",
+            job="all",
+            dataset="read",
+            model="all",
+            checkpoint="read",
+            volume="all",
+            param1="value1",
+        )
+        expected_payload = dict(
+            email="newuser@gmail.com",
+            job="all",
+            dataset="read",
+            model="all",
+            checkpoint="read",
+            volume="all",
+        )
+        mock_proximl._query.assert_called_once_with(
+            "/project/1/access", "POST", dict(param1="value1"), expected_payload
+        )
+        assert result.email == "newuser@gmail.com"
+
     @mark.asyncio
     async def test_project_members_list(self, project_members, mock_proximl):
         api_response = [
@@ -72,6 +108,16 @@ class ProjectMembersTests:
         )
         assert len(resp) == 2
 
+    @mark.asyncio
+    async def test_project_members_remove(self, project_members, mock_proximl):
+        """Test remove method (line 35)."""
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await project_members.remove("user@gmail.com", param1="value1")
+        mock_proximl._query.assert_called_once_with(
+            "/project/1/access", "DELETE", dict(param1="value1", email="user@gmail.com")
+        )
+
 
 class ProjectMemberTests:
     def test_project_member_properties(self, project_member):

tests/unit/projects/test_project_services_unit.py

@@ -34,6 +34,24 @@ def project_service(mock_proximl):
 
 
 class ProjectServicesTests:
+    @mark.asyncio
+    async def test_project_services_get(self, project_services, mock_proximl):
+        """Test get method (lines 11-14)."""
+        api_response = {
+            "project_uuid": "proj-id-1",
+            "region_uuid": "reg-id-1",
+            "id": "res-id-1",
+            "type": "port",
+            "name": "On-Prem Service A",
+            "hostname": "service-a.local",
+        }
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        result = await project_services.get("res-id-1", param1="value1")
+        mock_proximl._query.assert_called_once_with(
+            "/project/1/services/res-id-1", "GET", dict(param1="value1")
+        )
+        assert result.id == "res-id-1"
+
     @mark.asyncio
     async def test_project_services_refresh(self, project_services, mock_proximl):
         api_response = dict()
@@ -100,3 +118,50 @@ class ProjectServiceTests:
         empty_project_service = specimen.ProjectService(mock_proximl)
         assert bool(project_service)
         assert not bool(empty_project_service)
+
+    @mark.asyncio
+    async def test_project_service_enable(self, project_service, mock_proximl):
+        """Test enable method (line 72)."""
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await project_service.enable()
+        mock_proximl._query.assert_called_once_with(
+            "/project/proj-id-1/services/res-id-1/enable", "PATCH"
+        )
+
+    @mark.asyncio
+    async def test_project_service_disable(self, project_service, mock_proximl):
+        """Test disable method (line 77)."""
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await project_service.disable()
+        mock_proximl._query.assert_called_once_with(
+            "/project/proj-id-1/services/res-id-1/disable", "PATCH"
+        )
+
+    @mark.asyncio
+    async def test_project_service_get_service_ca_certificate(self, project_service, mock_proximl):
+        """Test get_service_ca_certificate method (lines 82-87)."""
+        api_response = {"certificate": "ca-cert-data"}
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        result = await project_service.get_service_ca_certificate(param1="value1")
+        mock_proximl._query.assert_called_once_with(
+            "/project/proj-id-1/services/res-id-1/certificate/ca",
+            "GET",
+            dict(param1="value1"),
+        )
+        assert result == api_response
+
+    @mark.asyncio
+    async def test_project_service_sign_client_certificate(self, project_service, mock_proximl):
+        """Test sign_client_certificate method (lines 90-96)."""
+        api_response = {"certificate": "signed-cert-data"}
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        result = await project_service.sign_client_certificate("csr-data", param1="value1")
+        mock_proximl._query.assert_called_once_with(
+            "/project/proj-id-1/services/res-id-1/certificate/sign",
+            "POST",
+            dict(param1="value1"),
+            dict(csr="csr-data"),
+        )
+        assert result == api_response

tests/unit/projects/test_projects_unit.py

@@ -48,6 +48,22 @@ class ProjectsTests:
         await projects.get("1234")
         mock_proximl._query.assert_called_once_with("/project/1234", "GET", dict())
 
+    @mark.asyncio
+    async def test_get_current_project(self, projects, mock_proximl):
+        """Test get_current method (lines 20-23)."""
+        api_response = {
+            "id": "project-id-1",
+            "name": "current project",
+            "owner": True,
+        }
+        mock_proximl.project = "project-id-1"
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        result = await projects.get_current(param1="value1")
+        mock_proximl._query.assert_called_once_with(
+            "/project/project-id-1", "GET", dict(param1="value1")
+        )
+        assert result.id == "project-id-1"
+
     @mark.asyncio
     async def test_list_projects(
         self,

tests/unit/test_auth_unit.py

@@ -6,7 +6,7 @@ from unittest.mock import AsyncMock, patch, mock_open, MagicMock
 from pytest import mark, fixture, raises
 from aiohttp import WSMessage, WSMsgType
 
-import proximl.auth as specimen
+import proximl.utils.auth as specimen
 
 pytestmark = [mark.sdk, mark.unit]
 
@@ -21,7 +21,22 @@ pytestmark = [mark.sdk, mark.unit]
         "PROXIML_POOL_ID": "pool_id",
     },
 )
-def test_auth_from_envs():
+@patch("proximl.utils.auth.boto3.client")
+@patch("proximl.utils.auth.requests.get")
+@patch("builtins.open", side_effect=FileNotFoundError)
+def test_auth_from_envs(mock_open, mock_requests_get, mock_boto3_client):
+    # Mock the auth config request
+    mock_response = MagicMock()
+    mock_response.json.return_value = {
+        "region": "us-east-1",
+        "userPoolSDKClientId": "default_client_id",
+        "userPoolId": "default_pool_id",
+    }
+    mock_requests_get.return_value = mock_response
+
+    # Mock boto3 client
+    mock_boto3_client.return_value = MagicMock()
+
     auth = specimen.Auth(config_dir=os.path.expanduser("~/.proximl"))
     assert auth.__dict__.get("username") == "user-id"
     assert auth.__dict__.get("password") == "key"