proximl 0.5.7__py3-none-any.whl → 0.5.9__py3-none-any.whl

tests/unit/projects/test_project_secrets_unit.py

@@ -0,0 +1,101 @@
+import re
+import json
+import logging
+from unittest.mock import AsyncMock, patch
+from pytest import mark, fixture, raises
+from aiohttp import WSMessage, WSMsgType
+
+import proximl.projects.secrets as specimen
+from proximl.exceptions import (
+    ApiError,
+    SpecificationError,
+    ProxiMLException,
+)
+
+pytestmark = [mark.sdk, mark.unit, mark.projects]
+
+
+@fixture
+def project_secrets(mock_proximl):
+    yield specimen.ProjectSecrets(mock_proximl, project_id="1")
+
+
+@fixture
+def project_service(mock_proximl):
+    yield specimen.ProjectSecret(
+        mock_proximl,
+        project_uuid="proj-id-1",
+        name="secret_value",
+    )
+
+
+class ProjectSecretsTests:
+    @mark.asyncio
+    async def test_project_secrets_list(self, project_secrets, mock_proximl):
+        api_response = [
+            {
+                "project_uuid": "proj-id-1",
+                "name": "secret_value",
+            },
+            {
+                "project_uuid": "proj-id-1",
+                "name": "secret_value_2",
+            },
+        ]
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        resp = await project_secrets.list()
+        mock_proximl._query.assert_called_once_with("/project/1/secrets", "GET", dict())
+        assert len(resp) == 2
+
+    @mark.asyncio
+    async def test_remove_project_secret(
+        self,
+        project_secrets,
+        mock_proximl,
+    ):
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await project_secrets.remove("secret_value")
+        mock_proximl._query.assert_called_once_with(
+            "/project/1/secret/secret_value", "DELETE", dict()
+        )
+
+    @mark.asyncio
+    async def test_put_project_secret(self, project_secrets, mock_proximl):
+        requested_config = dict(name="secret_value", value="ASKHJSLKF")
+        expected_payload = dict(value="ASKHJSLKF")
+        api_response = {"project_uuid": "project-id-1", "name": "secret_value"}
+
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        response = await project_secrets.put(**requested_config)
+        mock_proximl._query.assert_called_once_with(
+            "/project/1/secret/secret_value", "PUT", None, expected_payload
+        )
+        assert response.name == "secret_value"
+
+
+class ProjectSecretTests:
+    def test_project_service_properties(self, project_service):
+        assert isinstance(project_service.name, str)
+        assert isinstance(project_service.project_uuid, str)
+
+    def test_project_service_str(self, project_service):
+        string = str(project_service)
+        regex = r"^{.*\"name\": \"" + project_service.name + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_service_repr(self, project_service):
+        string = repr(project_service)
+        regex = (
+            r"^ProjectSecret\( proximl , \*\*{.*'name': '"
+            + project_service.name
+            + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_service_bool(self, project_service, mock_proximl):
+        empty_project_service = specimen.ProjectSecret(mock_proximl)
+        assert bool(project_service)
+        assert not bool(empty_project_service)

tests/unit/projects/test_project_services_unit.py

@@ -0,0 +1,102 @@
+import re
+import json
+import logging
+from unittest.mock import AsyncMock, patch
+from pytest import mark, fixture, raises
+from aiohttp import WSMessage, WSMsgType
+
+import proximl.projects.services as specimen
+from proximl.exceptions import (
+    ApiError,
+    SpecificationError,
+    ProxiMLException,
+)
+
+pytestmark = [mark.sdk, mark.unit, mark.projects]
+
+
+@fixture
+def project_services(mock_proximl):
+    yield specimen.ProjectServices(mock_proximl, project_id="1")
+
+
+@fixture
+def project_service(mock_proximl):
+    yield specimen.ProjectService(
+        mock_proximl,
+        id="res-id-1",
+        name="service 1",
+        project_uuid="proj-id-1",
+        region_uuid="reg-id-1",
+        public=False,
+        hostname="asdf.proximl.cloud",
+    )
+
+
+class ProjectServicesTests:
+    @mark.asyncio
+    async def test_project_services_refresh(self, project_services, mock_proximl):
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await project_services.refresh()
+        mock_proximl._query.assert_called_once_with("/project/1/services", "PATCH")
+
+    @mark.asyncio
+    async def test_project_services_list(self, project_services, mock_proximl):
+        api_response = [
+            {
+                "project_uuid": "proj-id-1",
+                "region_uuid": "reg-id-1",
+                "id": "res-id-1",
+                "type": "port",
+                "name": "On-Prem Service A",
+                "resource": "8001",
+                "hostname": "service-a.local",
+            },
+            {
+                "project_uuid": "proj-id-1",
+                "region_uuid": "reg-id-2",
+                "id": "res-id-2",
+                "type": "port",
+                "name": "Cloud Service B",
+                "resource": "8001",
+                "hostname": "service-b.local",
+            },
+        ]
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        resp = await project_services.list()
+        mock_proximl._query.assert_called_once_with(
+            "/project/1/services", "GET", dict()
+        )
+        assert len(resp) == 2
+
+
+class ProjectServiceTests:
+    def test_project_service_properties(self, project_service):
+        assert isinstance(project_service.id, str)
+        assert isinstance(project_service.name, str)
+        assert isinstance(project_service.project_uuid, str)
+        assert isinstance(project_service.hostname, str)
+        assert isinstance(project_service.public, bool)
+        assert isinstance(project_service.region_uuid, str)
+
+    def test_project_service_str(self, project_service):
+        string = str(project_service)
+        regex = r"^{.*\"id\": \"" + project_service.id + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_service_repr(self, project_service):
+        string = repr(project_service)
+        regex = (
+            r"^ProjectService\( proximl , \*\*{.*'id': '"
+            + project_service.id
+            + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_service_bool(self, project_service, mock_proximl):
+        empty_project_service = specimen.ProjectService(mock_proximl)
+        assert bool(project_service)
+        assert not bool(empty_project_service)

tests/unit/projects/test_projects_unit.py

@@ -0,0 +1,128 @@
+import re
+import json
+import logging
+from unittest.mock import AsyncMock, patch
+from pytest import mark, fixture, raises
+from aiohttp import WSMessage, WSMsgType
+
+import proximl.projects as specimen
+from proximl.exceptions import (
+    ApiError,
+    SpecificationError,
+    ProxiMLException,
+)
+
+pytestmark = [mark.sdk, mark.unit, mark.projects]
+
+
+@fixture
+def projects(mock_proximl):
+    yield specimen.Projects(mock_proximl)
+
+
+@fixture
+def project(mock_proximl):
+    yield specimen.Project(
+        mock_proximl,
+        id="1",
+        name="My Mock Project",
+        owner=True,
+        owner_name="Me",
+        created_name="Me",
+        job_all=True,
+        dataset_all=True,
+        model_all=True,
+        createdAt="2020-12-31T23:59:59.000Z",
+    )
+
+
+class ProjectsTests:
+    @mark.asyncio
+    async def test_get_project(
+        self,
+        projects,
+        mock_proximl,
+    ):
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await projects.get("1234")
+        mock_proximl._query.assert_called_once_with("/project/1234", "GET", dict())
+
+    @mark.asyncio
+    async def test_list_projects(
+        self,
+        projects,
+        mock_proximl,
+    ):
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await projects.list()
+        mock_proximl._query.assert_called_once_with("/project", "GET", dict())
+
+    @mark.asyncio
+    async def test_remove_project(
+        self,
+        projects,
+        mock_proximl,
+    ):
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await projects.remove("4567")
+        mock_proximl._query.assert_called_once_with("/project/4567", "DELETE", dict())
+
+    @mark.asyncio
+    async def test_create_project_simple(self, projects, mock_proximl):
+        requested_config = dict(
+            name="new project",
+        )
+        expected_payload = dict(name="new project", copy_keys=False, copy_secrets=False)
+        api_response = {
+            "id": "project-id-1",
+            "name": "new project",
+            "owner": True,
+            "owner_name": "Me",
+            "created_name": "Me",
+            "job_all": True,
+            "dataset_all": True,
+            "model_all": True,
+            "createdAt": "2020-12-31T23:59:59.000Z",
+        }
+
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        response = await projects.create(**requested_config)
+        mock_proximl._query.assert_called_once_with(
+            "/project", "POST", None, expected_payload
+        )
+        assert response.id == "project-id-1"
+
+
+class ProjectTests:
+    def test_project_properties(self, project):
+        assert isinstance(project.id, str)
+        assert isinstance(project.name, str)
+        assert isinstance(project.owner_name, str)
+        assert isinstance(project.is_owner, bool)
+
+    def test_project_str(self, project):
+        string = str(project)
+        regex = r"^{.*\"id\": \"" + project.id + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_repr(self, project):
+        string = repr(project)
+        regex = r"^Project\( proximl , \*\*{.*'id': '" + project.id + r"'.*}\)$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_bool(self, project, mock_proximl):
+        empty_project = specimen.Project(mock_proximl)
+        assert bool(project)
+        assert not bool(empty_project)
+
+    @mark.asyncio
+    async def test_project_remove(self, project, mock_proximl):
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await project.remove()
+        mock_proximl._query.assert_called_once_with("/project/1", "DELETE")

tests/unit/test_auth_unit.py

@@ -0,0 +1,30 @@
+import re
+import logging
+import json
+import os
+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
+
+pytestmark = [mark.sdk, mark.unit]
+
+
+@patch.dict(
+    os.environ,
+    {
+        "PROXIML_USER": "user-id",
+        "PROXIML_KEY": "key",
+        "PROXIML_REGION": "ap-east-1",
+        "PROXIML_CLIENT_ID": "client_id",
+        "PROXIML_POOL_ID": "pool_id",
+    },
+)
+def test_auth_from_envs():
+    auth = specimen.Auth(config_dir=os.path.expanduser("~/.proximl"))
+    assert auth.__dict__.get("username") == "user-id"
+    assert auth.__dict__.get("password") == "key"
+    assert auth.__dict__.get("region") == "ap-east-1"
+    assert auth.__dict__.get("client_id") == "client_id"
+    assert auth.__dict__.get("pool_id") == "pool_id"

tests/unit/test_proximl_unit.py

@@ -0,0 +1,54 @@
+import re
+import logging
+import json
+import os
+from unittest.mock import AsyncMock, patch, mock_open
+from pytest import mark, fixture, raises
+from aiohttp import WSMessage, WSMsgType
+
+import proximl.proximl as specimen
+
+pytestmark = [mark.sdk, mark.unit]
+
+
+@patch.dict(
+    os.environ,
+    {
+        "PROXIML_USER": "user-id",
+        "PROXIML_KEY": "key",
+        "PROXIML_REGION": "region",
+        "PROXIML_CLIENT_ID": "client_id",
+        "PROXIML_POOL_ID": "pool_id",
+        "PROXIML_API_URL": "api.example.com",
+        "PROXIML_WS_URL": "api-ws.example.com",
+    },
+)
+def test_proximl_from_envs():
+    proximl = specimen.ProxiML()
+    assert proximl.__dict__.get("api_url") == "api.example.com"
+    assert proximl.__dict__.get("ws_url") == "api-ws.example.com"
+    assert proximl.auth.__dict__.get("username") == "user-id"
+    assert proximl.auth.__dict__.get("password") == "key"
+    assert proximl.auth.__dict__.get("region") == "region"
+    assert proximl.auth.__dict__.get("client_id") == "client_id"
+    assert proximl.auth.__dict__.get("pool_id") == "pool_id"
+
+
+def test_proximl_env_from_files():
+    with patch(
+        "proximl.proximl.open",
+        mock_open(
+            read_data=json.dumps(
+                dict(
+                    region="region_file",
+                    client_id="client_id_file",
+                    pool_id="pool_id_file",
+                    api_url="api.example.com_file",
+                    ws_url="api-ws.example.com_file",
+                )
+            )
+        ),
+    ):
+        proximl = specimen.ProxiML()
+    assert proximl.__dict__.get("api_url") == "api.example.com_file"
+    assert proximl.__dict__.get("ws_url") == "api-ws.example.com_file"