proximl 0.5.10__py3-none-any.whl → 0.5.11__py3-none-any.whl

tests/unit/cli/test_cli_project_unit.py

@@ -1,46 +0,0 @@
-import re
-import json
-import click
-from unittest.mock import AsyncMock, patch, create_autospec
-from pytest import mark, fixture, raises
-
-pytestmark = [mark.cli, mark.unit, mark.projects]
-
-from proximl.cli import project as specimen
-from proximl.projects import Project
-
-
-def test_list(runner, mock_projects):
-    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
-        mock_proximl.projects = AsyncMock()
-        mock_proximl.projects.list = AsyncMock(return_value=mock_projects)
-        result = runner.invoke(specimen, ["list"])
-        print(result)
-        assert result.exit_code == 0
-        mock_proximl.projects.list.assert_called_once()
-
-
-def test_list_datastores(runner, mock_project_datastores):
-    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
-        mock_project = create_autospec(Project)
-        mock_project.list_datastores = AsyncMock(
-            return_value=mock_project_datastores
-        )
-        mock_proximl.projects.get = AsyncMock(return_value=mock_project)
-        result = runner.invoke(specimen, ["list-datastores"])
-        print(result)
-        assert result.exit_code == 0
-        mock_project.list_datastores.assert_called_once()
-
-
-def test_list_reservations(runner, mock_project_reservations):
-    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
-        mock_project = create_autospec(Project)
-        mock_project.list_reservations = AsyncMock(
-            return_value=mock_project_reservations
-        )
-        mock_proximl.projects.get = AsyncMock(return_value=mock_project)
-        result = runner.invoke(specimen, ["list-reservations"])
-        print(result)
-        assert result.exit_code == 0
-        mock_project.list_reservations.assert_called_once()

tests/unit/cloudbender/test_reservations_unit.py

@@ -1,173 +0,0 @@
-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.cloudbender.reservations as specimen
-from proximl.exceptions import (
-    ApiError,
-    SpecificationError,
-    ProxiMLException,
-)
-
-pytestmark = [mark.sdk, mark.unit, mark.cloudbender, mark.reservations]
-
-
-@fixture
-def reservations(mock_proximl):
-    yield specimen.Reservations(mock_proximl)
-
-
-@fixture
-def reservation(mock_proximl):
-    yield specimen.Reservation(
-        mock_proximl,
-        provider_uuid="1",
-        region_uuid="a",
-        reservation_id="x",
-        name="On-Prem Reservation",
-        type="port",
-        resource="8001",
-        hostname="service.local",
-    )
-
-
-class RegionsTests:
-    @mark.asyncio
-    async def test_get_reservation(
-        self,
-        reservations,
-        mock_proximl,
-    ):
-        api_response = dict()
-        mock_proximl._query = AsyncMock(return_value=api_response)
-        await reservations.get("1234", "5687", "91011")
-        mock_proximl._query.assert_called_once_with(
-            "/provider/1234/region/5687/reservation/91011", "GET", {}
-        )
-
-    @mark.asyncio
-    async def test_list_reservations(
-        self,
-        reservations,
-        mock_proximl,
-    ):
-        api_response = dict()
-        mock_proximl._query = AsyncMock(return_value=api_response)
-        await reservations.list("1234", "5687")
-        mock_proximl._query.assert_called_once_with(
-            "/provider/1234/region/5687/reservation", "GET", {}
-        )
-
-    @mark.asyncio
-    async def test_remove_reservation(
-        self,
-        reservations,
-        mock_proximl,
-    ):
-        api_response = dict()
-        mock_proximl._query = AsyncMock(return_value=api_response)
-        await reservations.remove("1234", "4567", "8910")
-        mock_proximl._query.assert_called_once_with(
-            "/provider/1234/region/4567/reservation/8910", "DELETE", {}
-        )
-
-    @mark.asyncio
-    async def test_create_reservation(self, reservations, mock_proximl):
-        requested_config = dict(
-            provider_uuid="provider-id-1",
-            region_uuid="region-id-1",
-            name="On-Prem Reservation",
-            type="port",
-            resource="8001",
-            hostname="service.local",
-        )
-        expected_payload = dict(
-            name="On-Prem Reservation",
-            type="port",
-            resource="8001",
-            hostname="service.local",
-        )
-        api_response = {
-            "provider_uuid": "provider-id-1",
-            "region_uuid": "region-id-1",
-            "reservation_id": "reservation-id-1",
-            "name": "On-Prem Reservation",
-            "type": "port",
-            "resource": "8001",
-            "hostname": "service.local",
-            "createdAt": "2020-12-31T23:59:59.000Z",
-        }
-
-        mock_proximl._query = AsyncMock(return_value=api_response)
-        response = await reservations.create(**requested_config)
-        mock_proximl._query.assert_called_once_with(
-            "/provider/provider-id-1/region/region-id-1/reservation",
-            "POST",
-            None,
-            expected_payload,
-        )
-        assert response.id == "reservation-id-1"
-
-
-class reservationTests:
-    def test_reservation_properties(self, reservation):
-        assert isinstance(reservation.id, str)
-        assert isinstance(reservation.provider_uuid, str)
-        assert isinstance(reservation.region_uuid, str)
-        assert isinstance(reservation.type, str)
-        assert isinstance(reservation.name, str)
-        assert isinstance(reservation.resource, str)
-        assert isinstance(reservation.hostname, str)
-
-    def test_reservation_str(self, reservation):
-        string = str(reservation)
-        regex = r"^{.*\"reservation_id\": \"" + reservation.id + r"\".*}$"
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_reservation_repr(self, reservation):
-        string = repr(reservation)
-        regex = (
-            r"^Reservation\( proximl , \*\*{.*'reservation_id': '"
-            + reservation.id
-            + r"'.*}\)$"
-        )
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_reservation_bool(self, reservation, mock_proximl):
-        empty_reservation = specimen.Reservation(mock_proximl)
-        assert bool(reservation)
-        assert not bool(empty_reservation)
-
-    @mark.asyncio
-    async def test_reservation_remove(self, reservation, mock_proximl):
-        api_response = dict()
-        mock_proximl._query = AsyncMock(return_value=api_response)
-        await reservation.remove()
-        mock_proximl._query.assert_called_once_with(
-            "/provider/1/region/a/reservation/x", "DELETE"
-        )
-
-    @mark.asyncio
-    async def test_reservation_refresh(self, reservation, mock_proximl):
-        api_response = {
-            "provider_uuid": "provider-id-1",
-            "region_uuid": "region-id-1",
-            "reservation_id": "reservation-id-1",
-            "name": "On-Prem Reservation",
-            "type": "port",
-            "resource": "8001",
-            "hostname": "service.local",
-            "createdAt": "2020-12-31T23:59:59.000Z",
-        }
-        mock_proximl._query = AsyncMock(return_value=api_response)
-        response = await reservation.refresh()
-        mock_proximl._query.assert_called_once_with(
-            f"/provider/1/region/a/reservation/x", "GET"
-        )
-        assert reservation.id == "reservation-id-1"
-        assert response.id == "reservation-id-1"

tests/unit/test_auth.py

@@ -1,30 +0,0 @@
-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_projects_unit.py

@@ -1,294 +0,0 @@
-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",
-    )
-
-
-@fixture
-def project_datastore(mock_proximl):
-    yield specimen.ProjectDatastore(
-        mock_proximl,
-        id="ds-id-1",
-        name="datastore 1",
-        project_uuid="proj-id-1",
-        type="nfs",
-        region_uuid="reg-id-1",
-    )
-
-
-@fixture
-def project_reservation(mock_proximl):
-    yield specimen.ProjectReservation(
-        mock_proximl,
-        id="res-id-1",
-        name="reservation 1",
-        project_uuid="proj-id-1",
-        region_uuid="reg-id-1",
-        type="port",
-        resource="8001",
-        hostname="service.local",
-    )
-
-
-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)
-        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 ProjectDatastoreTests:
-    def test_project_datastore_properties(self, project_datastore):
-        assert isinstance(project_datastore.id, str)
-        assert isinstance(project_datastore.name, str)
-        assert isinstance(project_datastore.project_uuid, str)
-        assert isinstance(project_datastore.type, str)
-        assert isinstance(project_datastore.region_uuid, str)
-
-    def test_project_datastore_str(self, project_datastore):
-        string = str(project_datastore)
-        regex = r"^{.*\"id\": \"" + project_datastore.id + r"\".*}$"
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_project_datastore_repr(self, project_datastore):
-        string = repr(project_datastore)
-        regex = (
-            r"^ProjectDatastore\( proximl , \*\*{.*'id': '"
-            + project_datastore.id
-            + r"'.*}\)$"
-        )
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_project_datastore_bool(self, project_datastore, mock_proximl):
-        empty_project_datastore = specimen.ProjectDatastore(mock_proximl)
-        assert bool(project_datastore)
-        assert not bool(empty_project_datastore)
-
-
-class ProjectReservationTests:
-    def test_project_reservation_properties(self, project_reservation):
-        assert isinstance(project_reservation.id, str)
-        assert isinstance(project_reservation.name, str)
-        assert isinstance(project_reservation.project_uuid, str)
-        assert isinstance(project_reservation.type, str)
-        assert isinstance(project_reservation.hostname, str)
-        assert isinstance(project_reservation.resource, str)
-        assert isinstance(project_reservation.region_uuid, str)
-
-    def test_project_reservation_str(self, project_reservation):
-        string = str(project_reservation)
-        regex = r"^{.*\"id\": \"" + project_reservation.id + r"\".*}$"
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_project_reservation_repr(self, project_reservation):
-        string = repr(project_reservation)
-        regex = (
-            r"^ProjectReservation\( proximl , \*\*{.*'id': '"
-            + project_reservation.id
-            + r"'.*}\)$"
-        )
-        assert isinstance(string, str)
-        assert re.match(regex, string)
-
-    def test_project_reservation_bool(self, project_reservation, mock_proximl):
-        empty_project_reservation = specimen.ProjectReservation(mock_proximl)
-        assert bool(project_reservation)
-        assert not bool(empty_project_reservation)
-
-
-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")
-
-    @mark.asyncio
-    async def test_project_refresh_datastores(self, project, mock_proximl):
-        api_response = dict()
-        mock_proximl._query = AsyncMock(return_value=api_response)
-        await project.refresh_datastores()
-        mock_proximl._query.assert_called_once_with(
-            "/project/1/datastores", "PATCH"
-        )
-
-    @mark.asyncio
-    async def test_project_refresh_reservations(self, project, mock_proximl):
-        api_response = dict()
-        mock_proximl._query = AsyncMock(return_value=api_response)
-        await project.refresh_reservations()
-        mock_proximl._query.assert_called_once_with(
-            "/project/1/reservations", "PATCH"
-        )
-
-    @mark.asyncio
-    async def test_project_list_datastores(self, project, mock_proximl):
-        api_response = [
-            {
-                "project_uuid": "proj-id-1",
-                "region_uuid": "reg-id-1",
-                "id": "store-id-1",
-                "type": "nfs",
-                "name": "On-prem NFS",
-            },
-            {
-                "project_uuid": "proj-id-1",
-                "region_uuid": "reg-id-2",
-                "id": "store-id-2",
-                "type": "smb",
-                "name": "GCP Samba",
-            },
-        ]
-        mock_proximl._query = AsyncMock(return_value=api_response)
-        resp = await project.list_datastores()
-        mock_proximl._query.assert_called_once_with(
-            "/project/1/datastores", "GET"
-        )
-        assert len(resp) == 2
-
-    @mark.asyncio
-    async def test_project_list_reservations(self, project, 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.list_reservations()
-        mock_proximl._query.assert_called_once_with(
-            "/project/1/reservations", "GET"
-        )
-        assert len(resp) == 2

tests/unit/test_proximl.py

@@ -1,54 +0,0 @@
-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"