proximl 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

proximl/cli/cloudbender/device.py

@@ -0,0 +1,157 @@
+import click
+from proximl.cli import cli, pass_config, search_by_id_name
+from proximl.cli.cloudbender import cloudbender
+
+
+@cloudbender.group()
+@pass_config
+def device(config):
+    """proxiML CloudBender device commands."""
+    pass
+
+
+@device.command()
+@click.option(
+    "--provider",
+    "-p",
+    type=click.STRING,
+    required=True,
+    help="The provider ID of the region.",
+)
+@click.option(
+    "--region",
+    "-r",
+    type=click.STRING,
+    required=True,
+    help="The region ID to list devices for.",
+)
+@pass_config
+def list(config, provider, region):
+    """List devices."""
+    data = [
+        [
+            "ID",
+            "NAME",
+            "STATUS",
+            "JOB STATUS",
+            "ONLINE",
+            "MAINTENANCE",
+        ],
+        [
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+            "-" * 80,
+        ],
+    ]
+
+    devices = config.proximl.run(
+        config.proximl.client.cloudbender.devices.list(
+            provider_uuid=provider, region_uuid=region
+        )
+    )
+
+    for device in devices:
+        data.append(
+            [
+                device.id,
+                device.name,
+                device.status,
+                device.job_status,
+                "X" if device.online else "",
+                "X" if device.maintenance_mode else "",
+            ]
+        )
+
+    for row in data:
+        click.echo(
+            "{: >37.36} {: >29.28} {: >9.8} {: >11.10} {: >7.6} {: >12.11}"
+            "".format(*row),
+            file=config.stdout,
+        )
+
+
+@device.command()
+@click.option(
+    "--provider",
+    "-p",
+    type=click.STRING,
+    required=True,
+    help="The provider ID of the region.",
+)
+@click.option(
+    "--region",
+    "-r",
+    type=click.STRING,
+    required=True,
+    help="The region ID to create the region in.",
+)
+@click.option(
+    "--minion-id",
+    "-m",
+    type=click.STRING,
+    required=True,
+    help="The minion_id of the new node.",
+)
+@click.option(
+    "--hostname",
+    "-h",
+    type=click.STRING,
+    help="The hostname (if different from name)",
+)
+@click.argument("name", type=click.STRING, required=True)
+@pass_config
+def create(config, provider, region, minion_id, hostname, name):
+    """
+    Creates a node.
+    """
+    if not hostname:
+        hostname = name
+    return config.proximl.run(
+        config.proximl.client.cloudbender.devices.create(
+            provider_uuid=provider,
+            region_uuid=region,
+            friendly_name=name,
+            hostname=hostname,
+            minion_id=minion_id,
+        )
+    )
+
+
+@device.command()
+@click.option(
+    "--provider",
+    "-p",
+    type=click.STRING,
+    required=True,
+    help="The provider ID of the region.",
+)
+@click.option(
+    "--region",
+    "-r",
+    type=click.STRING,
+    required=True,
+    help="The region ID to delete the node from.",
+)
+@click.argument("device", type=click.STRING)
+@pass_config
+def remove(config, provider, region, node):
+    """
+    Remove a device.
+
+    DEVICE may be specified by name or ID, but ID is preferred.
+    """
+    devices = config.proximl.run(
+        config.proximl.client.cloudbender.devices.list(
+            provider_uuid=provider, region_uuid=region
+        )
+    )
+
+    found = search_by_id_name(device, devices)
+    if None is found:
+        raise click.UsageError("Cannot find specified device.")
+
+    return config.proximl.run(found.remove())

proximl/cloudbender/devices.py

@@ -0,0 +1,190 @@
+import json
+import logging
+
+
+class Devices(object):
+    def __init__(self, proximl):
+        self.proximl = proximl
+
+    async def get(self, provider_uuid, region_uuid, id, **kwargs):
+        resp = await self.proximl._query(
+            f"/provider/{provider_uuid}/region/{region_uuid}/device/{id}",
+            "GET",
+            kwargs,
+        )
+        return Device(self.proximl, **resp)
+
+    async def list(self, provider_uuid, region_uuid, **kwargs):
+        resp = await self.proximl._query(
+            f"/provider/{provider_uuid}/region/{region_uuid}/device",
+            "GET",
+            kwargs,
+        )
+        devices = [Device(self.proximl, **device) for device in resp]
+        return devices
+
+    async def create(
+        self,
+        provider_uuid,
+        region_uuid,
+        friendly_name,
+        hostname,
+        minion_id,
+        **kwargs,
+    ):
+        logging.info(f"Creating Device {friendly_name}")
+        data = dict(
+            friendly_name=friendly_name,
+            hostname=hostname,
+            minion_id=minion_id,
+            type="device",
+            service="compute",
+            **kwargs,
+        )
+        payload = {k: v for k, v in data.items() if v is not None}
+        resp = await self.proximl._query(
+            f"/provider/{provider_uuid}/region/{region_uuid}/device",
+            "POST",
+            None,
+            payload,
+        )
+        device = Device(self.proximl, **resp)
+        logging.info(f"Created Device {friendly_name} with id {device.id}")
+        return device
+
+    async def remove(self, provider_uuid, region_uuid, id, **kwargs):
+        await self.proximl._query(
+            f"/provider/{provider_uuid}/region/{region_uuid}/device/{id}",
+            "DELETE",
+            kwargs,
+        )
+
+
+class Device:
+    def __init__(self, proximl, **kwargs):
+        self.proximl = proximl
+        self._device = kwargs
+        self._id = self._device.get("device_id")
+        self._provider_uuid = self._device.get("provider_uuid")
+        self._region_uuid = self._device.get("region_uuid")
+        self._name = self._device.get("friendly_name")
+        self._hostname = self._device.get("hostname")
+        self._status = self._device.get("status")
+        self._online = self._device.get("online")
+        self._maintenance_mode = self._device.get("maintenance_mode")
+        self._device_config_id = self._device.get("device_config_id")
+        self._job_status = self._device.get("job_status")
+        self._job_last_deployed = self._device.get("job_last_deployed")
+        self._job_config_id = self._device.get("job_config_id")
+        self._job_config_revision = self._device.get("job_config_revision")
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def provider_uuid(self) -> str:
+        return self._provider_uuid
+
+    @property
+    def region_uuid(self) -> str:
+        return self._region_uuid
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def hostname(self) -> str:
+        return self._hostname
+
+    @property
+    def status(self) -> str:
+        return self._status
+
+    @property
+    def online(self) -> bool:
+        return self._online
+
+    @property
+    def maintenance_mode(self) -> bool:
+        return self._maintenance_mode
+
+    @property
+    def device_config_id(self) -> str:
+        return self._device_config_id
+
+    @property
+    def job_status(self) -> str:
+        return self._job_status
+
+    @property
+    def job_last_deployed(self) -> str:
+        return self._job_last_deployed
+
+    @property
+    def job_config_id(self) -> str:
+        return self._job_config_id
+
+    @property
+    def job_config_revision(self) -> str:
+        return self._job_config_revision
+
+    def __str__(self):
+        return json.dumps({k: v for k, v in self._device.items()})
+
+    def __repr__(self):
+        return f"Device( proximl , **{self._device.__repr__()})"
+
+    def __bool__(self):
+        return bool(self._id)
+
+    async def remove(self):
+        await self.proximl._query(
+            f"/provider/{self._provider_uuid}/region/{self._region_uuid}/device/{self._id}",
+            "DELETE",
+        )
+
+    async def refresh(self):
+        resp = await self.proximl._query(
+            f"/provider/{self._provider_uuid}/region/{self._region_uuid}/device/{self._id}",
+            "GET",
+        )
+        self.__init__(self.proximl, **resp)
+        return self
+
+    async def toggle_maintenance(self):
+        await self.proximl._query(
+            f"/provider/{self._provider_uuid}/region/{self._region_uuid}/device/{self._id}/maintenance",
+            "PATCH",
+        )
+
+    async def run_action(self, command):
+        await self.proximl._query(
+            f"/provider/{self._provider_uuid}/region/{self._region_uuid}/device/{self._id}/action",
+            "POST",
+            None,
+            dict(command=command),
+        )
+
+    async def set_config(self, device_config_id):
+        resp = await self.proximl._query(
+            f"/provider/{self._provider_uuid}/region/{self._region_uuid}/device/{self._id}",
+            "PATCH",
+            None,
+            dict(device_config_id=device_config_id),
+        )
+        self.__init__(self.proximl, **resp)
+        return self
+
+    async def deploy_endpoint(self):
+        await self.proximl._query(
+            f"/provider/{self._provider_uuid}/region/{self._region_uuid}/device/{self._id}/deploy",
+            "PUT",
+        )
+
+    async def stop_endpoint(self):
+        await self.proximl._query(
+            f"/provider/{self._provider_uuid}/region/{self._region_uuid}/device/{self._id}/stop",
+            "PUT",
+        )

{proximl-0.5.0.dist-info → proximl-0.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: proximl
-Version: 0.5.0
+Version: 0.5.2
 Summary: proxiML client SDK and command line utilities
 Home-page: https://github.com/proxiML/python-sdk
 Author: proxiML

{proximl-0.5.0.dist-info → proximl-0.5.2.dist-info}/RECORD

@@ -25,6 +25,7 @@ proximl/cli/model.py,sha256=x1iG41tcYZuQdhA1qa_BQqLmpp0uteW6ieUCKlgzGRc,6071
 proximl/cli/project.py,sha256=Er1twSiWQSAKir-hBIT9fRo2fc_UGqFoIJOwwjQGmlo,3522
 proximl/cli/cloudbender/__init__.py,sha256=qWLg19Gq-2WHnBZZ4Un10QyY8ipNOA0_LK-Lm9yeM4w,484
 proximl/cli/cloudbender/datastore.py,sha256=_vQOj-NfrL_nj4HfxNJL63TJZjLgfDyztRLyaRU58v8,3478
+proximl/cli/cloudbender/device.py,sha256=FdQZPESP6YBfUSzXq1Byu7eNMKi59qSOICONK-TEljI,3453
 proximl/cli/cloudbender/node.py,sha256=xxzj68YvpRey2vZQasgYTnwv3x7TnwpuPSSf8Ma5a54,3843
 proximl/cli/cloudbender/provider.py,sha256=qhWbDK1tWi00wQWEYqGw7yGoZx0nEjV40GLHRuuE86c,1726
 proximl/cli/cloudbender/region.py,sha256=WnSkY4dXKRJ-FNaoxMfmoh6iuUx5dXCNJmEFT34Xtao,2892
@@ -35,6 +36,7 @@ proximl/cloudbender/__init__.py,sha256=iE29obtC0_9f0IhRvHQcG5aY58fVhVYipTakpjAhd
 proximl/cloudbender/cloudbender.py,sha256=Bn4l7ypAi4HzQbhrL_Ss0MY6S775CNaZ87YUxp9rD8Y,565
 proximl/cloudbender/datastores.py,sha256=rE_6A2rH-muET3mFus9oXU8jPc2y5poZFs_O7cuWx4M,3245
 proximl/cloudbender/device_configs.py,sha256=7kvnSZ68kZEkUymPMNlCIJUTg5fMIJCNrODbPZAkLdc,3134
+proximl/cloudbender/devices.py,sha256=vHooaOw2k2Tf99FJHnVZTgggqCTYJg7rq46aUPW0k8M,5660
 proximl/cloudbender/nodes.py,sha256=85mC7H8MkU4tGiyk51GjKgK7O9XBuKQu94Rg7ECqFnc,3608
 proximl/cloudbender/providers.py,sha256=-DxBpWgKteBacwNluUxrKST4HuyneNg57bz1y9CcUko,1834
 proximl/cloudbender/regions.py,sha256=7mkjWjrpJjRjlkzOWZlxzGo4HgrfPvhITwAeBZfXnDo,3339
@@ -74,6 +76,7 @@ tests/unit/cli/test_cli_model_unit.py,sha256=AucngxvYjW6GidDGBPHnKyYOb82ff7xMX5m
 tests/unit/cli/test_cli_project_unit.py,sha256=ms9gJ8pgMNGeIMdFcvBcwSPmb0i2qo9-rk9CCF53-9M,1756
 tests/unit/cli/cloudbender/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/unit/cli/cloudbender/test_cli_datastore_unit.py,sha256=sUZWnzzCCG7NdgzEHsQ2zHpEb-ZD6FDIazca6FqMOc0,1381
+tests/unit/cli/cloudbender/test_cli_device_unit.py,sha256=o1vrPlbaanYK1iJG5pE6tDwgmOXDuLUY0VH8DxtaPYI,1342
 tests/unit/cli/cloudbender/test_cli_node_unit.py,sha256=uh1Nt0ewk0v81iN5wCyBPzSXAhD8clW98HAORsCjqrg,1316
 tests/unit/cli/cloudbender/test_cli_provider_unit.py,sha256=jCnFnqZuLzuDx9u3kLyjT83nBDWKn7LDCz6ErzCce1g,781
 tests/unit/cli/cloudbender/test_cli_region_unit.py,sha256=mEAU0z_gKDM-e5J_V8igXmiU4qjrOfzJJRtKRNWdeBs,1262
@@ -81,13 +84,14 @@ tests/unit/cli/cloudbender/test_cli_reservation_unit.py,sha256=Lcr-xeNVAtVLHllQn
 tests/unit/cloudbender/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/unit/cloudbender/test_datastores_unit.py,sha256=Sk-qg4fpBSkW8D3cnnfjAQdWjADtV9uHfLpqexl0loo,4644
 tests/unit/cloudbender/test_device_configs_unit.py,sha256=Dp8GaeD0lEt9giVAX6f3r_G0ELLgIZux_887gR32M3M,4858
+tests/unit/cloudbender/test_devices_unit.py,sha256=C2YTnfIpHlxdidgfbTnlzl72r5O7kqKStQUhWcTTXDg,9103
 tests/unit/cloudbender/test_nodes_unit.py,sha256=vk6lWGr1PBWeJZNIVywPN_UzwuZdRW3xZuh_iT0gCeA,4686
 tests/unit/cloudbender/test_providers_unit.py,sha256=8KURiz5zz2saBcAYIPPvLBx3wVOUhN5kK36MD64-oyw,3730
 tests/unit/cloudbender/test_regions_unit.py,sha256=4QivFfejiI8cI47DsmJGgDw-tY9ENol3dKRwcVEDpr0,5635
 tests/unit/cloudbender/test_reservations_unit.py,sha256=MlUWr8cXM7n-CTqd4sfFaZMEV6jka802Hnhmg6dAeGU,4827
-proximl-0.5.0.dist-info/LICENSE,sha256=ADFxLEZDxKY0j4MdyUd5GNuhQ18rnWH5rOz1ZG7yiOA,1069
-proximl-0.5.0.dist-info/METADATA,sha256=rG8H63Jf_vO5rUI5xdSeDDR9PT9bsGhjgMIx1YLaMgs,7344
-proximl-0.5.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-proximl-0.5.0.dist-info/entry_points.txt,sha256=HmI311IIabkZReMCXu-nGbvIEW-KfaduAOyfiSqt5SY,63
-proximl-0.5.0.dist-info/top_level.txt,sha256=-TWqc9tAaxmWmW4c7uYsmzPEYUIoh6z02xxqPbv7Kys,23
-proximl-0.5.0.dist-info/RECORD,,
+proximl-0.5.2.dist-info/LICENSE,sha256=ADFxLEZDxKY0j4MdyUd5GNuhQ18rnWH5rOz1ZG7yiOA,1069
+proximl-0.5.2.dist-info/METADATA,sha256=fc1Q36A0tQBo_Gb3KoPlCqfOOopX0WvMOtjXqyAiRC8,7344
+proximl-0.5.2.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+proximl-0.5.2.dist-info/entry_points.txt,sha256=HmI311IIabkZReMCXu-nGbvIEW-KfaduAOyfiSqt5SY,63
+proximl-0.5.2.dist-info/top_level.txt,sha256=-TWqc9tAaxmWmW4c7uYsmzPEYUIoh6z02xxqPbv7Kys,23
+proximl-0.5.2.dist-info/RECORD,,

tests/unit/cli/cloudbender/test_cli_device_unit.py

@@ -0,0 +1,38 @@
+import re
+import json
+import click
+from unittest.mock import AsyncMock, patch
+from pytest import mark, fixture, raises
+
+pytestmark = [mark.cli, mark.unit, mark.cloudbender, mark.devices]
+
+from proximl.cli.cloudbender import device as specimen
+from proximl.cloudbender.devices import Device
+
+
+def test_list(runner, mock_devices):
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+        mock_proximl.cloudbender = AsyncMock()
+        mock_proximl.cloudbender.devices = AsyncMock()
+        mock_proximl.cloudbender.devices.list = AsyncMock(
+            return_value=mock_devices
+        )
+        result = runner.invoke(
+            specimen,
+            args=["list", "--provider=prov-id-1", "--region=reg-id-1"],
+        )
+        assert result.exit_code == 0
+        mock_proximl.cloudbender.devices.list.assert_called_once_with(
+            provider_uuid="prov-id-1", region_uuid="reg-id-1"
+        )
+
+
+def test_list_no_provider(runner, mock_devices):
+    with patch("proximl.cli.ProxiML", new=AsyncMock) as mock_proximl:
+        mock_proximl.cloudbender = AsyncMock()
+        mock_proximl.cloudbender.devices = AsyncMock()
+        mock_proximl.cloudbender.devices.list = AsyncMock(
+            return_value=mock_devices
+        )
+        result = runner.invoke(specimen, ["list"])
+        assert result.exit_code != 0

tests/unit/cloudbender/test_devices_unit.py

@@ -0,0 +1,270 @@
+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.devices as specimen
+from proximl.exceptions import (
+    ApiError,
+    SpecificationError,
+    ProxiMLException,
+)
+
+pytestmark = [mark.sdk, mark.unit, mark.cloudbender, mark.devices]
+
+
+@fixture
+def devices(mock_proximl):
+    yield specimen.Devices(mock_proximl)
+
+
+@fixture
+def device(mock_proximl):
+    yield specimen.Device(
+        mock_proximl,
+        provider_uuid="1",
+        region_uuid="a",
+        device_id="x",
+        type="device",
+        service="compute",
+        friendly_name="hq-orin-01",
+        hostname="hq-orin-01",
+        status="active",
+        online=True,
+        maintenance_mode=False,
+        job_status="stopped",
+        job_last_deployed="2023-06-02T21:22:40.084Z",
+        job_config_id="job-id-1",
+        job_config_revision="1685740490096",
+        device_config_id="conf-id-2",
+    )
+
+
+class RegionsTests:
+    @mark.asyncio
+    async def test_get_device(
+        self,
+        devices,
+        mock_proximl,
+    ):
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await devices.get("1234", "5687", "91011")
+        mock_proximl._query.assert_called_once_with(
+            "/provider/1234/region/5687/device/91011", "GET", {}
+        )
+
+    @mark.asyncio
+    async def test_list_devices(
+        self,
+        devices,
+        mock_proximl,
+    ):
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await devices.list("1234", "5687")
+        mock_proximl._query.assert_called_once_with(
+            "/provider/1234/region/5687/device", "GET", {}
+        )
+
+    @mark.asyncio
+    async def test_remove_device(
+        self,
+        devices,
+        mock_proximl,
+    ):
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await devices.remove("1234", "4567", "8910")
+        mock_proximl._query.assert_called_once_with(
+            "/provider/1234/region/4567/device/8910", "DELETE", {}
+        )
+
+    @mark.asyncio
+    async def test_create_device(self, devices, mock_proximl):
+        requested_config = dict(
+            provider_uuid="provider-id-1",
+            region_uuid="region-id-1",
+            friendly_name="phys-device",
+            hostname="phys-device",
+            minion_id="asdf",
+        )
+        expected_payload = dict(
+            friendly_name="phys-device",
+            hostname="phys-device",
+            minion_id="asdf",
+            type="device",
+            service="compute",
+        )
+        api_response = {
+            "provider_uuid": "provider-id-1",
+            "region_uuid": "region-id-1",
+            "device_id": "rig-id-1",
+            "name": "phys-device",
+            "type": "device",
+            "service": "compute",
+            "status": "new",
+            "online": False,
+            "maintenance_mode": True,
+            "job_status": "stopped",
+            "job_last_deployed": "2023-06-02T21:22:40.084Z",
+            "job_config_id": "job-id-1",
+            "job_config_revision": "1685740490096",
+            "device_config_id": "conf-id-1",
+            "createdAt": "2020-12-31T23:59:59.000Z",
+        }
+
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        response = await devices.create(**requested_config)
+        mock_proximl._query.assert_called_once_with(
+            "/provider/provider-id-1/region/region-id-1/device",
+            "POST",
+            None,
+            expected_payload,
+        )
+        assert response.id == "rig-id-1"
+
+
+class deviceTests:
+    def test_device_properties(self, device):
+        assert isinstance(device.id, str)
+        assert isinstance(device.provider_uuid, str)
+        assert isinstance(device.region_uuid, str)
+        assert isinstance(device.name, str)
+        assert isinstance(device.hostname, str)
+        assert isinstance(device.status, str)
+        assert isinstance(device.online, bool)
+        assert isinstance(device.maintenance_mode, bool)
+        assert isinstance(device.device_config_id, str)
+        assert isinstance(device.job_status, str)
+        assert isinstance(device.job_last_deployed, str)
+        assert isinstance(device.job_config_id, str)
+        assert isinstance(device.job_config_revision, str)
+
+    def test_device_str(self, device):
+        string = str(device)
+        regex = r"^{.*\"device_id\": \"" + device.id + r"\".*}$"
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_device_repr(self, device):
+        string = repr(device)
+        regex = (
+            r"^Device\( proximl , \*\*{.*'device_id': '"
+            + device.id
+            + r"'.*}\)$"
+        )
+        assert isinstance(string, str)
+        assert re.match(regex, string)
+
+    def test_device_bool(self, device, mock_proximl):
+        empty_device = specimen.Device(mock_proximl)
+        assert bool(device)
+        assert not bool(empty_device)
+
+    @mark.asyncio
+    async def test_device_remove(self, device, mock_proximl):
+        api_response = dict()
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await device.remove()
+        mock_proximl._query.assert_called_once_with(
+            "/provider/1/region/a/device/x", "DELETE"
+        )
+
+    @mark.asyncio
+    async def test_device_refresh(self, device, mock_proximl):
+        api_response = {
+            "provider_uuid": "provider-id-1",
+            "region_uuid": "region-id-1",
+            "device_id": "device-id-1",
+            "name": "phys-device",
+            "type": "device",
+            "service": "compute",
+            "status": "new",
+            "online": False,
+            "maintenance_mode": True,
+            "job_status": "stopped",
+            "job_last_deployed": "2023-06-02T21:22:40.084Z",
+            "job_config_id": "job-id-1",
+            "job_config_revision": "1685740490096",
+            "device_config_id": "conf-id-1",
+            "createdAt": "2020-12-31T23:59:59.000Z",
+        }
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        response = await device.refresh()
+        mock_proximl._query.assert_called_once_with(
+            f"/provider/1/region/a/device/x", "GET"
+        )
+        assert device.id == "device-id-1"
+        assert response.id == "device-id-1"
+
+    @mark.asyncio
+    async def test_device_toggle_maintenance(self, device, mock_proximl):
+        api_response = None
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await device.toggle_maintenance()
+        mock_proximl._query.assert_called_once_with(
+            "/provider/1/region/a/device/x/maintenance", "PATCH"
+        )
+
+    @mark.asyncio
+    async def test_device_run_action(self, device, mock_proximl):
+        api_response = None
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await device.run_action(command="report")
+        mock_proximl._query.assert_called_once_with(
+            "/provider/1/region/a/device/x/action",
+            "POST",
+            None,
+            dict(command="report"),
+        )
+
+    @mark.asyncio
+    async def test_device_set_config(self, device, mock_proximl):
+        api_response = {
+            "provider_uuid": "provider-id-1",
+            "region_uuid": "region-id-1",
+            "device_id": "device-id-1",
+            "name": "phys-device",
+            "type": "device",
+            "service": "compute",
+            "status": "new",
+            "online": False,
+            "maintenance_mode": True,
+            "job_status": "stopped",
+            "job_last_deployed": "2023-06-02T21:22:40.084Z",
+            "job_config_id": "job-id-1",
+            "job_config_revision": "1685740490096",
+            "device_config_id": "config-id-1",
+            "createdAt": "2020-12-31T23:59:59.000Z",
+        }
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        response = await device.set_config(device_config_id="config-id-1")
+        mock_proximl._query.assert_called_once_with(
+            "/provider/1/region/a/device/x",
+            "PATCH",
+            None,
+            dict(device_config_id="config-id-1"),
+        )
+        assert device.id == "device-id-1"
+        assert response.id == "device-id-1"
+
+    @mark.asyncio
+    async def test_device_deploy_endpoint(self, device, mock_proximl):
+        api_response = None
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await device.deploy_endpoint()
+        mock_proximl._query.assert_called_once_with(
+            "/provider/1/region/a/device/x/deploy", "PUT"
+        )
+
+    @mark.asyncio
+    async def test_device_stop_endpoint(self, device, mock_proximl):
+        api_response = None
+        mock_proximl._query = AsyncMock(return_value=api_response)
+        await device.stop_endpoint()
+        mock_proximl._query.assert_called_once_with(
+            "/provider/1/region/a/device/x/stop", "PUT"
+        )