trainml 0.5.8__tar.gz → 0.5.9__tar.gz

{trainml-0.5.8 → trainml-0.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: trainml
-Version: 0.5.8
+Version: 0.5.9
 Summary: trainML client SDK and command line utilities
 Home-page: https://github.com/trainML/trainml-cli
 Author: trainML

trainml-0.5.9/tests/integration/projects/conftest.py

@@ -0,0 +1,8 @@
+from pytest import fixture
+
+
+@fixture(scope="module")
+async def project(trainml):
+    project = await trainml.projects.create(name="New Project", copy_keys=False)
+    yield project
+    await project.remove()

{trainml-0.5.8/tests/integration → trainml-0.5.9/tests/integration/projects}/test_projects_integration.py

@@ -9,12 +9,6 @@ pytestmark = [mark.sdk, mark.integration, mark.projects]
 @mark.create
 @mark.asyncio
 class GetProjectsTests:
-    @fixture(scope="class")
-    async def project(self, trainml):
-        project = await trainml.projects.create(name="New Project", copy_keys=False)
-        yield project
-        await project.remove()
-
     async def test_get_projects(self, trainml):
         projects = await trainml.projects.list()
         assert len(projects) > 0

trainml-0.5.9/tests/integration/projects/test_projects_keys_integration.py

@@ -0,0 +1,43 @@
+import re
+import sys
+import asyncio
+from pytest import mark, fixture
+
+pytestmark = [mark.sdk, mark.integration, mark.projects]
+
+
+@mark.create
+@mark.asyncio
+class ProjectKeysTests:
+    @fixture(scope="class")
+    async def project_key(self, project):
+        project_key = await project.keys.put(
+            type="aws", key_id="ASFHALKF", secret="IUHKLHKAHF"
+        )
+        yield project_key
+        await project.keys.remove(type="aws")
+
+    async def test_list_project_keys(self, project, project_key):
+        keys = await project.keys.list()
+        assert len(keys) > 0
+
+    async def test_project_key_properties(self, project, project_key):
+        assert isinstance(project_key.project_uuid, str)
+        assert isinstance(project_key.type, str)
+        assert isinstance(project_key.key_id, str)
+        assert project_key.type == "aws"
+        assert project.id == project_key.project_uuid
+
+    async def test_project_key_str(self, project_key):
+        string = str(project_key)
+        regex = r"^{.*\"type\": \"" + project_key.type + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    async def test_project_key_repr(self, project_key):
+        string = repr(project_key)
+        regex = (
+            r"^ProjectKey\( trainml , \*\*{.*'type': '" + project_key.type + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)

trainml-0.5.9/tests/integration/projects/test_projects_secrets_integration.py

@@ -0,0 +1,44 @@
+import re
+import sys
+import asyncio
+from pytest import mark, fixture
+
+pytestmark = [mark.sdk, mark.integration, mark.projects]
+
+
+@mark.create
+@mark.asyncio
+class ProjectSecretsTests:
+    @fixture(scope="class")
+    async def project_secret(self, project):
+        project_secret = await project.secrets.put(
+            name="secret_value", value="IUHKLHKAHF"
+        )
+        yield project_secret
+        await project.secrets.remove(name="secret_value")
+
+    async def test_list_project_keys(self, project, project_secret):
+        secrets = await project.secrets.list()
+        assert len(secrets) > 0
+
+    async def test_project_secret_properties(self, project, project_secret):
+        assert isinstance(project_secret.project_uuid, str)
+        assert isinstance(project_secret.name, str)
+        assert project_secret.name == "secret_value"
+        assert project.id == project_secret.project_uuid
+
+    async def test_project_secret_str(self, project_secret):
+        string = str(project_secret)
+        regex = r"^{.*\"name\": \"" + project_secret.name + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    async def test_project_secret_repr(self, project_secret):
+        string = repr(project_secret)
+        regex = (
+            r"^ProjectSecret\( trainml , \*\*{.*'name': '"
+            + project_secret.name
+            + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)

{trainml-0.5.8 → trainml-0.5.9}/tests/unit/conftest.py

@@ -16,9 +16,11 @@ from trainml.connections import Connections
 from trainml.projects import (
     Projects,
     Project,
-    ProjectDatastore,
-    ProjectService,
 )
+from trainml.projects.datastores import ProjectDatastore
+from trainml.projects.services import ProjectService
+from trainml.projects.data_connectors import ProjectDataConnector
+
 from trainml.cloudbender import Cloudbender
 from trainml.cloudbender.providers import Provider, Providers
 from trainml.cloudbender.regions import Region, Regions
@@ -26,6 +28,7 @@ from trainml.cloudbender.nodes import Node, Nodes
 from trainml.cloudbender.devices import Device, Devices
 from trainml.cloudbender.datastores import Datastore, Datastores
 from trainml.cloudbender.services import Service, Services
+from trainml.cloudbender.data_connectors import DataConnector, DataConnectors
 from trainml.cloudbender.device_configs import DeviceConfig, DeviceConfigs
 
 
@@ -948,6 +951,68 @@ def mock_project_services():
     ]
 
 
+@fixture(scope="session")
+def mock_data_connectors():
+    trainml = Mock()
+    yield [
+        DataConnector(
+            trainml,
+            **{
+                "provider_uuid": "prov-id-1",
+                "region_uuid": "reg-id-1",
+                "connector_id": "con-id-1",
+                "type": "custom",
+                "name": "On-Prem Connection A",
+                "protocol": "TCP",
+                "port_range": "8000-8099",
+                "cidr": "10.0.3.0/24",
+            },
+        ),
+        DataConnector(
+            trainml,
+            **{
+                "provider_uuid": "prov-id-2",
+                "region_uuid": "reg-id-2",
+                "connector_id": "con-id-2",
+                "type": "custom",
+                "name": "Cloud Connection B",
+                "protocol": "UDP",
+                "port_range": "5000",
+                "cidr": "10.0.2.0/24",
+            },
+        ),
+    ]
+
+
+@fixture(
+    scope="session",
+)
+def mock_project_data_connectors():
+    trainml = Mock()
+    yield [
+        ProjectDataConnector(
+            trainml,
+            **{
+                "project_uuid": "proj-id-1",
+                "region_uuid": "reg-id-1",
+                "id": "con-id-1",
+                "type": "custom",
+                "name": "On-Prem Connection A",
+            },
+        ),
+        ProjectDataConnector(
+            trainml,
+            **{
+                "project_uuid": "proj-id-1",
+                "region_uuid": "reg-id-2",
+                "id": "con-id-2",
+                "type": "custom",
+                "name": "Cloud Connection B",
+            },
+        ),
+    ]
+
+
 @fixture(scope="session")
 def mock_device_configs():
     trainml = Mock()
@@ -991,6 +1056,7 @@ def mock_trainml(
     mock_devices,
     mock_datastores,
     mock_services,
+    mock_data_connectors,
     mock_device_configs,
 ):
     trainml = create_autospec(TrainML)
@@ -1030,6 +1096,10 @@ def mock_trainml(
     trainml.cloudbender.datastores.list = AsyncMock(return_value=mock_datastores)
     trainml.cloudbender.services = create_autospec(Services)
     trainml.cloudbender.services.list = AsyncMock(return_value=mock_services)
+    trainml.cloudbender.data_connectors = create_autospec(DataConnectors)
+    trainml.cloudbender.data_connectors.list = AsyncMock(
+        return_value=mock_data_connectors
+    )
     trainml.cloudbender.device_configs = create_autospec(DeviceConfigs)
     trainml.cloudbender.device_configs.list = AsyncMock(
         return_value=mock_device_configs

trainml-0.5.9/tests/unit/projects/test_project_data_connectors_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 trainml.projects.data_connectors as specimen
+from trainml.exceptions import (
+    ApiError,
+    SpecificationError,
+    TrainMLException,
+)
+
+pytestmark = [mark.sdk, mark.unit, mark.projects]
+
+
+@fixture
+def project_data_connectors(mock_trainml):
+    yield specimen.ProjectDataConnectors(mock_trainml, project_id="1")
+
+
+@fixture
+def project_data_connector(mock_trainml):
+    yield specimen.ProjectDataConnector(
+        mock_trainml,
+        id="ds-id-1",
+        name="connector 1",
+        project_uuid="proj-id-1",
+        type="custom",
+        region_uuid="reg-id-1",
+    )
+
+
+class ProjectDataConnectorsTests:
+    @mark.asyncio
+    async def test_project_data_connectors_refresh(
+        self, project_data_connectors, mock_trainml
+    ):
+        api_response = dict()
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        await project_data_connectors.refresh()
+        mock_trainml._query.assert_called_once_with(
+            "/project/1/data_connectors", "PATCH"
+        )
+
+    @mark.asyncio
+    async def test_project_data_connectors_list(
+        self, project_data_connectors, mock_trainml
+    ):
+        api_response = [
+            {
+                "project_uuid": "proj-id-1",
+                "region_uuid": "reg-id-1",
+                "id": "store-id-1",
+                "type": "custom",
+                "name": "On-Prem Connection A",
+            },
+            {
+                "project_uuid": "proj-id-1",
+                "region_uuid": "reg-id-2",
+                "id": "store-id-2",
+                "type": "custom",
+                "name": "Cloud Connection B",
+            },
+        ]
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        resp = await project_data_connectors.list()
+        mock_trainml._query.assert_called_once_with(
+            "/project/1/data_connectors", "GET", dict()
+        )
+        assert len(resp) == 2
+
+
+class ProjectDataConnectorTests:
+    def test_project_data_connector_properties(self, project_data_connector):
+        assert isinstance(project_data_connector.id, str)
+        assert isinstance(project_data_connector.name, str)
+        assert isinstance(project_data_connector.project_uuid, str)
+        assert isinstance(project_data_connector.type, str)
+        assert isinstance(project_data_connector.region_uuid, str)
+
+    def test_project_data_connector_str(self, project_data_connector):
+        string = str(project_data_connector)
+        regex = r"^{.*\"id\": \"" + project_data_connector.id + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_data_connector_repr(self, project_data_connector):
+        string = repr(project_data_connector)
+        regex = (
+            r"^ProjectDataConnector\( trainml , \*\*{.*'id': '"
+            + project_data_connector.id
+            + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_data_connector_bool(self, project_data_connector, mock_trainml):
+        empty_project_data_connector = specimen.ProjectDataConnector(mock_trainml)
+        assert bool(project_data_connector)
+        assert not bool(empty_project_data_connector)

trainml-0.5.9/tests/unit/projects/test_project_datastores_unit.py

@@ -0,0 +1,96 @@
+import re
+import json
+import logging
+from unittest.mock import AsyncMock, patch
+from pytest import mark, fixture, raises
+from aiohttp import WSMessage, WSMsgType
+
+import trainml.projects.datastores as specimen
+from trainml.exceptions import (
+    ApiError,
+    SpecificationError,
+    TrainMLException,
+)
+
+pytestmark = [mark.sdk, mark.unit, mark.projects]
+
+
+@fixture
+def project_datastores(mock_trainml):
+    yield specimen.ProjectDatastores(mock_trainml, project_id="1")
+
+
+@fixture
+def project_datastore(mock_trainml):
+    yield specimen.ProjectDatastore(
+        mock_trainml,
+        id="ds-id-1",
+        name="datastore 1",
+        project_uuid="proj-id-1",
+        type="nfs",
+        region_uuid="reg-id-1",
+    )
+
+
+class ProjectDatastoresTests:
+    @mark.asyncio
+    async def test_project_datastores_refresh(self, project_datastores, mock_trainml):
+        api_response = dict()
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        await project_datastores.refresh()
+        mock_trainml._query.assert_called_once_with("/project/1/datastores", "PATCH")
+
+    @mark.asyncio
+    async def test_project_datastores_list(self, project_datastores, mock_trainml):
+        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_trainml._query = AsyncMock(return_value=api_response)
+        resp = await project_datastores.list()
+        mock_trainml._query.assert_called_once_with(
+            "/project/1/datastores", "GET", dict()
+        )
+        assert len(resp) == 2
+
+
+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\( trainml , \*\*{.*'id': '"
+            + project_datastore.id
+            + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_datastore_bool(self, project_datastore, mock_trainml):
+        empty_project_datastore = specimen.ProjectDatastore(mock_trainml)
+        assert bool(project_datastore)
+        assert not bool(empty_project_datastore)

trainml-0.5.9/tests/unit/projects/test_project_keys_unit.py

@@ -0,0 +1,96 @@
+import re
+import json
+import logging
+from unittest.mock import AsyncMock, patch
+from pytest import mark, fixture, raises
+from aiohttp import WSMessage, WSMsgType
+
+import trainml.projects.keys as specimen
+from trainml.exceptions import (
+    ApiError,
+    SpecificationError,
+    TrainMLException,
+)
+
+pytestmark = [mark.sdk, mark.unit, mark.projects]
+
+
+@fixture
+def project_keys(mock_trainml):
+    yield specimen.ProjectKeys(mock_trainml, project_id="1")
+
+
+@fixture
+def project_key(mock_trainml):
+    yield specimen.ProjectKey(
+        mock_trainml, project_uuid="proj-id-1", type="aws", key_id="AIYHGFSDLK"
+    )
+
+
+class ProjectKeysTests:
+    @mark.asyncio
+    async def test_project_keys_list(self, project_keys, mock_trainml):
+        api_response = [
+            {"project_uuid": "proj-id-1", "type": "aws", "key_id": "AIYHGFSDLK"},
+            {"project_uuid": "proj-id-1", "type": "gcp", "key_id": "credentials.json"},
+        ]
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        resp = await project_keys.list()
+        mock_trainml._query.assert_called_once_with("/project/1/keys", "GET", dict())
+        assert len(resp) == 2
+
+    @mark.asyncio
+    async def test_remove_project_key(
+        self,
+        project_keys,
+        mock_trainml,
+    ):
+        api_response = dict()
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        await project_keys.remove("aws")
+        mock_trainml._query.assert_called_once_with(
+            "/project/1/key/aws", "DELETE", dict()
+        )
+
+    @mark.asyncio
+    async def test_put_project_key(self, project_keys, mock_trainml):
+        requested_config = dict(type="aws", key_id="AIUDHADA", secret="ASKHJSLKF")
+        expected_payload = dict(key_id="AIUDHADA", secret="ASKHJSLKF")
+        api_response = {
+            "project_uuid": "project-id-1",
+            "type": "aws",
+            "key_id": "AIUDHADA",
+        }
+
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        response = await project_keys.put(**requested_config)
+        mock_trainml._query.assert_called_once_with(
+            "/project/1/key/aws", "PUT", None, expected_payload
+        )
+        assert response.type == "aws"
+
+
+class ProjectKeyTests:
+    def test_project_key_properties(self, project_key):
+        assert isinstance(project_key.type, str)
+        assert isinstance(project_key.key_id, str)
+        assert isinstance(project_key.project_uuid, str)
+
+    def test_project_key_str(self, project_key):
+        string = str(project_key)
+        regex = r"^{.*\"type\": \"" + project_key.type + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_key_repr(self, project_key):
+        string = repr(project_key)
+        regex = (
+            r"^ProjectKey\( trainml , \*\*{.*'type': '" + project_key.type + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_key_bool(self, project_key, mock_trainml):
+        empty_project_key = specimen.ProjectKey(mock_trainml)
+        assert bool(project_key)
+        assert not bool(empty_project_key)

trainml-0.5.9/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 trainml.projects.secrets as specimen
+from trainml.exceptions import (
+    ApiError,
+    SpecificationError,
+    TrainMLException,
+)
+
+pytestmark = [mark.sdk, mark.unit, mark.projects]
+
+
+@fixture
+def project_secrets(mock_trainml):
+    yield specimen.ProjectSecrets(mock_trainml, project_id="1")
+
+
+@fixture
+def project_service(mock_trainml):
+    yield specimen.ProjectSecret(
+        mock_trainml,
+        project_uuid="proj-id-1",
+        name="secret_value",
+    )
+
+
+class ProjectSecretsTests:
+    @mark.asyncio
+    async def test_project_secrets_list(self, project_secrets, mock_trainml):
+        api_response = [
+            {
+                "project_uuid": "proj-id-1",
+                "name": "secret_value",
+            },
+            {
+                "project_uuid": "proj-id-1",
+                "name": "secret_value_2",
+            },
+        ]
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        resp = await project_secrets.list()
+        mock_trainml._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_trainml,
+    ):
+        api_response = dict()
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        await project_secrets.remove("secret_value")
+        mock_trainml._query.assert_called_once_with(
+            "/project/1/secret/secret_value", "DELETE", dict()
+        )
+
+    @mark.asyncio
+    async def test_put_project_secret(self, project_secrets, mock_trainml):
+        requested_config = dict(name="secret_value", value="ASKHJSLKF")
+        expected_payload = dict(value="ASKHJSLKF")
+        api_response = {"project_uuid": "project-id-1", "name": "secret_value"}
+
+        mock_trainml._query = AsyncMock(return_value=api_response)
+        response = await project_secrets.put(**requested_config)
+        mock_trainml._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\( trainml , \*\*{.*'name': '"
+            + project_service.name
+            + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_project_service_bool(self, project_service, mock_trainml):
+        empty_project_service = specimen.ProjectSecret(mock_trainml)
+        assert bool(project_service)
+        assert not bool(empty_project_service)