bug: add test to cross check function arguments, and fix some method implementations and naming.

2024-01-15 10:16:47 -07:00
parent 269e6aac14
commit 672e753afb
6 changed files with 106 additions and 111 deletions
--- a/pyasic/miners/antminer/hiveon/X9/T9.py
+++ b/pyasic/miners/antminer/hiveon/X9/T9.py
@@ -30,7 +30,7 @@ class HiveonT9(Hiveon, T9):
    ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
    ##################################################

-    async def _get_mac(self):
+    async def get_mac(self):
        try:
            mac = (
                (await self.send_ssh_command("cat /sys/class/net/eth0/address"))
@@ -41,7 +41,7 @@ class HiveonT9(Hiveon, T9):
        except (TypeError, ValueError, asyncssh.Error, OSError, AttributeError):
            pass

-    async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
+    async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
        hashboards = [
            HashBoard(slot=board, expected_chips=self.expected_chips)
            for board in range(self.expected_hashboards)
@@ -69,21 +69,21 @@ class HiveonT9(Hiveon, T9):
                        hashboards[board].chip_temp = api_stats["STATS"][1][
                            f"temp2_{chipset}"
                        ]
-                    except LookupError:
+                    except (KeyError, IndexError):
                        pass
                    else:
                        hashboards[board].missing = False
                try:
                    hashrate += api_stats["STATS"][1][f"chain_rate{chipset}"]
                    chips += api_stats["STATS"][1][f"chain_acn{chipset}"]
-                except LookupError:
+                except (KeyError, IndexError):
                    pass
            hashboards[board].hashrate = round(hashrate / 1000, 2)
            hashboards[board].chips = chips

        return hashboards

-    async def _get_wattage(self, api_stats: dict = None) -> Optional[int]:
+    async def get_wattage(self, api_stats: dict = None) -> Optional[int]:
        if not api_stats:
            try:
                api_stats = await self.api.stats()
@@ -94,13 +94,13 @@ class HiveonT9(Hiveon, T9):
            boards = api_stats.get("STATS")
            try:
                wattage_raw = boards[1]["chain_power"]
-            except LookupError:
+            except (KeyError, IndexError):
                pass
            else:
                # parse wattage position out of raw data
                return round(float(wattage_raw.split(" ")[0]))

-    async def _get_env_temp(self, api_stats: dict = None) -> Optional[float]:
+    async def get_env_temp(self, api_stats: dict = None) -> Optional[float]:
        env_temp_list = []
        board_map = {
            0: [2, 9, 10],
@@ -119,7 +119,7 @@ class HiveonT9(Hiveon, T9):
                        env_temp = api_stats["STATS"][1][f"temp3_{chipset}"]
                        if not env_temp == 0:
                            env_temp_list.append(int(env_temp))
-                    except LookupError:
+                    except (KeyError, IndexError):
                        pass

            if not env_temp_list == []:
--- a/pyasic/miners/backends/btminer.py
+++ b/pyasic/miners/backends/btminer.py
@@ -557,7 +557,6 @@ class BTMiner(BaseMiner):
                        errors.append(WhatsminerError(error_code=err))
            except (LookupError, ValueError, TypeError):
                pass
-
        return errors

    async def _get_expected_hashrate(self, api_summary: dict = None):
--- a/pyasic/miners/backends/cgminer_avalon.py
+++ b/pyasic/miners/backends/cgminer_avalon.py
@@ -14,6 +14,7 @@
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------

+import logging
 import re
 from typing import List, Optional

@@ -27,41 +28,42 @@ from pyasic.miners.base import DataFunction, DataLocations, DataOptions, RPCAPIC
 AVALON_DATA_LOC = DataLocations(
    **{
        str(DataOptions.MAC): DataFunction(
-            "_get_mac", [RPCAPICommand("api_version", "version")]
+            "get_mac", [RPCAPICommand("api_version", "version")]
        ),
+        str(DataOptions.MODEL): DataFunction("get_model"),
        str(DataOptions.API_VERSION): DataFunction(
-            "_get_api_ver", [RPCAPICommand("api_version", "version")]
+            "get_api_ver", [RPCAPICommand("api_version", "version")]
        ),
        str(DataOptions.FW_VERSION): DataFunction(
-            "_get_fw_ver", [RPCAPICommand("api_version", "version")]
+            "get_fw_ver", [RPCAPICommand("api_version", "version")]
        ),
-        str(DataOptions.HOSTNAME): DataFunction("_get_hostname"),
+        str(DataOptions.HOSTNAME): DataFunction("get_hostname"),
        str(DataOptions.HASHRATE): DataFunction(
-            "_get_hashrate", [RPCAPICommand("api_devs", "devs")]
+            "get_hashrate", [RPCAPICommand("api_devs", "devs")]
        ),
        str(DataOptions.EXPECTED_HASHRATE): DataFunction(
-            "_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
+            "get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
        ),
        str(DataOptions.HASHBOARDS): DataFunction(
-            "_get_hashboards", [RPCAPICommand("api_stats", "stats")]
+            "get_hashboards", [RPCAPICommand("api_stats", "stats")]
        ),
        str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
-            "_get_env_temp", [RPCAPICommand("api_stats", "stats")]
+            "get_env_temp", [RPCAPICommand("api_stats", "stats")]
        ),
-        str(DataOptions.WATTAGE): DataFunction("_get_wattage"),
+        str(DataOptions.WATTAGE): DataFunction("get_wattage"),
        str(DataOptions.WATTAGE_LIMIT): DataFunction(
-            "_get_wattage_limit", [RPCAPICommand("api_stats", "stats")]
+            "get_wattage_limit", [RPCAPICommand("api_stats", "stats")]
        ),
        str(DataOptions.FANS): DataFunction(
-            "_get_fans", [RPCAPICommand("api_stats", "stats")]
+            "get_fans", [RPCAPICommand("api_stats", "stats")]
        ),
-        str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
-        str(DataOptions.ERRORS): DataFunction("_get_errors"),
+        str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
+        str(DataOptions.ERRORS): DataFunction("get_errors"),
        str(DataOptions.FAULT_LIGHT): DataFunction(
-            "_get_fault_light", [RPCAPICommand("api_stats", "stats")]
+            "get_fault_light", [RPCAPICommand("api_stats", "stats")]
        ),
-        str(DataOptions.IS_MINING): DataFunction("_is_mining"),
-        str(DataOptions.UPTIME): DataFunction("_get_uptime"),
+        str(DataOptions.IS_MINING): DataFunction("is_mining"),
+        str(DataOptions.UPTIME): DataFunction("get_uptime"),
        str(DataOptions.CONFIG): DataFunction("get_config"),
    }
 )
@@ -172,7 +174,7 @@ class CGMinerAvalon(CGMiner):
    ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
    ##################################################

-    async def _get_mac(self, api_version: dict = None) -> Optional[str]:
+    async def get_mac(self, api_version: dict = None) -> Optional[str]:
        if not api_version:
            try:
                api_version = await self.api.version()
@@ -190,7 +192,7 @@ class CGMinerAvalon(CGMiner):
            except (KeyError, ValueError):
                pass

-    async def _get_hostname(self) -> Optional[str]:
+    async def get_hostname(self) -> Optional[str]:
        return None
        # if not mac:
        #     mac = await self.get_mac()
@@ -198,7 +200,7 @@ class CGMinerAvalon(CGMiner):
        # if mac:
        #     return f"Avalon{mac.replace(':', '')[-6:]}"

-    async def _get_hashrate(self, api_devs: dict = None) -> Optional[float]:
+    async def get_hashrate(self, api_devs: dict = None) -> Optional[float]:
        if not api_devs:
            try:
                api_devs = await self.api.devs()
@@ -208,10 +210,10 @@ class CGMinerAvalon(CGMiner):
        if api_devs:
            try:
                return round(float(api_devs["DEVS"][0]["MHS 1m"] / 1000000), 2)
-            except (LookupError, ValueError, TypeError):
+            except (KeyError, IndexError, ValueError, TypeError):
                pass

-    async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
+    async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
        hashboards = [
            HashBoard(slot=i, expected_chips=self.expected_chips)
            for i in range(self.expected_hashboards)
@@ -227,7 +229,7 @@ class CGMinerAvalon(CGMiner):
            try:
                unparsed_stats = api_stats["STATS"][0]["MM ID0"]
                parsed_stats = self.parse_stats(unparsed_stats)
-            except (LookupError, ValueError, TypeError):
+            except (IndexError, KeyError, ValueError, TypeError):
                return hashboards

            for board in range(self.expected_hashboards):
@@ -259,7 +261,7 @@ class CGMinerAvalon(CGMiner):

        return hashboards

-    async def _get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
+    async def get_expected_hashrate(self, api_stats: dict = None) -> Optional[float]:
        if not api_stats:
            try:
                api_stats = await self.api.stats()
@@ -271,10 +273,10 @@ class CGMinerAvalon(CGMiner):
                unparsed_stats = api_stats["STATS"][0]["MM ID0"]
                parsed_stats = self.parse_stats(unparsed_stats)
                return round(float(parsed_stats["GHSmm"]) / 1000, 2)
-            except (LookupError, ValueError, TypeError):
+            except (IndexError, KeyError, ValueError, TypeError):
                pass

-    async def _get_env_temp(self, api_stats: dict = None) -> Optional[float]:
+    async def get_env_temp(self, api_stats: dict = None) -> Optional[float]:
        if not api_stats:
            try:
                api_stats = await self.api.stats()
@@ -286,13 +288,13 @@ class CGMinerAvalon(CGMiner):
                unparsed_stats = api_stats["STATS"][0]["MM ID0"]
                parsed_stats = self.parse_stats(unparsed_stats)
                return float(parsed_stats["Temp"])
-            except (LookupError, ValueError, TypeError):
+            except (IndexError, KeyError, ValueError, TypeError):
                pass

-    async def _get_wattage(self) -> Optional[int]:
+    async def get_wattage(self) -> Optional[int]:
        return None

-    async def _get_wattage_limit(self, api_stats: dict = None) -> Optional[int]:
+    async def get_wattage_limit(self, api_stats: dict = None) -> Optional[int]:
        if not api_stats:
            try:
                api_stats = await self.api.stats()
@@ -304,17 +306,17 @@ class CGMinerAvalon(CGMiner):
                unparsed_stats = api_stats["STATS"][0]["MM ID0"]
                parsed_stats = self.parse_stats(unparsed_stats)
                return int(parsed_stats["MPO"])
-            except (LookupError, ValueError, TypeError):
+            except (IndexError, KeyError, ValueError, TypeError):
                pass

-    async def _get_fans(self, api_stats: dict = None) -> List[Fan]:
+    async def get_fans(self, api_stats: dict = None) -> List[Fan]:
        if not api_stats:
            try:
                api_stats = await self.api.stats()
            except APIError:
                pass

-        fans_data = [Fan() for _ in range(self.expected_fans)]
+        fans_data = [Fan() for _ in range(self.fan_count)]
        if api_stats:
            try:
                unparsed_stats = api_stats["STATS"][0]["MM ID0"]
@@ -322,17 +324,17 @@ class CGMinerAvalon(CGMiner):
            except LookupError:
                return fans_data

-            for fan in range(self.expected_fans):
+            for fan in range(self.fan_count):
                try:
                    fans_data[fan].speed = int(parsed_stats[f"Fan{fan + 1}"])
-                except (LookupError, ValueError, TypeError):
+                except (IndexError, KeyError, ValueError, TypeError):
                    pass
        return fans_data

-    async def _get_errors(self) -> List[MinerErrorData]:
+    async def get_errors(self) -> List[MinerErrorData]:
        return []

-    async def _get_fault_light(self, api_stats: dict = None) -> bool:  # noqa
+    async def get_fault_light(self, api_stats: dict = None) -> bool:  # noqa
        if self.light:
            return self.light
        if not api_stats:
@@ -347,7 +349,7 @@ class CGMinerAvalon(CGMiner):
                parsed_stats = self.parse_stats(unparsed_stats)
                led = int(parsed_stats["Led"])
                return True if led == 1 else False
-            except (LookupError, ValueError, TypeError):
+            except (IndexError, KeyError, ValueError, TypeError):
                pass

        try:
@@ -361,8 +363,8 @@ class CGMinerAvalon(CGMiner):
            pass
        return False

-    async def _is_mining(self, *args, **kwargs) -> Optional[bool]:
+    async def is_mining(self, *args, **kwargs) -> Optional[bool]:
        return None

-    async def _get_uptime(self) -> Optional[int]:
+    async def get_uptime(self) -> Optional[int]:
        return None
--- a/pyasic/miners/backends/hiveon.py
+++ b/pyasic/miners/backends/hiveon.py
@@ -22,39 +22,40 @@ from pyasic.miners.base import DataFunction, DataLocations, DataOptions, RPCAPIC

 HIVEON_DATA_LOC = DataLocations(
    **{
-        str(DataOptions.MAC): DataFunction("_get_mac"),
+        str(DataOptions.MAC): DataFunction("get_mac"),
+        str(DataOptions.MODEL): DataFunction("get_model"),
        str(DataOptions.API_VERSION): DataFunction(
-            "_get_api_ver", [RPCAPICommand("api_version", "version")]
+            "get_api_ver", [RPCAPICommand("api_version", "version")]
        ),
        str(DataOptions.FW_VERSION): DataFunction(
-            "_get_fw_ver", [RPCAPICommand("api_version", "version")]
+            "get_fw_ver", [RPCAPICommand("api_version", "version")]
        ),
-        str(DataOptions.HOSTNAME): DataFunction("_get_hostname"),
+        str(DataOptions.HOSTNAME): DataFunction("get_hostname"),
        str(DataOptions.HASHRATE): DataFunction(
-            "_get_hashrate", [RPCAPICommand("api_summary", "summary")]
+            "get_hashrate", [RPCAPICommand("api_summary", "summary")]
        ),
        str(DataOptions.EXPECTED_HASHRATE): DataFunction(
-            "_get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
+            "get_expected_hashrate", [RPCAPICommand("api_stats", "stats")]
        ),
        str(DataOptions.HASHBOARDS): DataFunction(
-            "_get_hashboards", [RPCAPICommand("api_stats", "stats")]
+            "get_hashboards", [RPCAPICommand("api_stats", "stats")]
        ),
        str(DataOptions.ENVIRONMENT_TEMP): DataFunction(
-            "_get_env_temp", [RPCAPICommand("api_stats", "stats")]
+            "get_env_temp", [RPCAPICommand("api_stats", "stats")]
        ),
        str(DataOptions.WATTAGE): DataFunction(
-            "_get_wattage", [RPCAPICommand("api_stats", "stats")]
+            "get_wattage", [RPCAPICommand("api_stats", "stats")]
        ),
-        str(DataOptions.WATTAGE_LIMIT): DataFunction("_get_wattage_limit"),
+        str(DataOptions.WATTAGE_LIMIT): DataFunction("get_wattage_limit"),
        str(DataOptions.FANS): DataFunction(
-            "_get_fans", [RPCAPICommand("api_stats", "stats")]
+            "get_fans", [RPCAPICommand("api_stats", "stats")]
        ),
-        str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
-        str(DataOptions.ERRORS): DataFunction("_get_errors"),
-        str(DataOptions.FAULT_LIGHT): DataFunction("_get_fault_light"),
-        str(DataOptions.IS_MINING): DataFunction("_is_mining"),
+        str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
+        str(DataOptions.ERRORS): DataFunction("get_errors"),
+        str(DataOptions.FAULT_LIGHT): DataFunction("get_fault_light"),
+        str(DataOptions.IS_MINING): DataFunction("is_mining"),
        str(DataOptions.UPTIME): DataFunction(
-            "_get_uptime", [RPCAPICommand("api_stats", "stats")]
+            "get_uptime", [RPCAPICommand("api_stats", "stats")]
        ),
        str(DataOptions.CONFIG): DataFunction("get_config"),
    }
@@ -67,15 +68,19 @@ class Hiveon(BMMiner):
        self.pwd = "admin"
        # static data
        self.api_type = "Hiveon"
-        self.fw_str = "Hive"
        # data gathering locations
        self.data_locations = HIVEON_DATA_LOC

-    async def _get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
+    async def get_model(self) -> Optional[str]:
+        if self.model is not None:
+            return self.model + " (Hiveon)"
+        return "? (Hiveon)"
+
+    async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
        pass

-    async def _get_wattage(self, api_stats: dict = None) -> Optional[int]:
+    async def get_wattage(self, api_stats: dict = None) -> Optional[int]:
        pass

-    async def _get_env_temp(self, api_stats: dict = None) -> Optional[float]:
+    async def get_env_temp(self, api_stats: dict = None) -> Optional[float]:
        pass
--- a/pyasic/miners/backends/innosilicon.py
+++ b/pyasic/miners/backends/innosilicon.py
@@ -33,67 +33,68 @@ from pyasic.web.innosilicon import InnosiliconWebAPI
 INNOSILICON_DATA_LOC = DataLocations(
    **{
        str(DataOptions.MAC): DataFunction(
-            "_get_mac",
+            "get_mac",
            [
                WebAPICommand("web_get_all", "getAll"),
                WebAPICommand("web_overview", "overview"),
            ],
        ),
+        str(DataOptions.MODEL): DataFunction("get_model"),
        str(DataOptions.API_VERSION): DataFunction(
-            "_get_api_ver", [RPCAPICommand("api_version", "version")]
+            "get_api_ver", [RPCAPICommand("api_version", "version")]
        ),
        str(DataOptions.FW_VERSION): DataFunction(
-            "_get_fw_ver", [RPCAPICommand("api_version", "version")]
+            "get_fw_ver", [RPCAPICommand("api_version", "version")]
        ),
-        str(DataOptions.HOSTNAME): DataFunction("_get_hostname"),
+        str(DataOptions.HOSTNAME): DataFunction("get_hostname"),
        str(DataOptions.HASHRATE): DataFunction(
-            "_get_hashrate",
+            "get_hashrate",
            [
                RPCAPICommand("api_summary", "summary"),
                WebAPICommand("web_get_all", "getAll"),
            ],
        ),
        str(DataOptions.EXPECTED_HASHRATE): DataFunction(
-            "_get_expected_hashrate",
+            "get_expected_hashrate",
        ),
        str(DataOptions.HASHBOARDS): DataFunction(
-            "_get_hashboards",
+            "get_hashboards",
            [
                RPCAPICommand("api_stats", "stats"),
                WebAPICommand("web_get_all", "getAll"),
            ],
        ),
-        str(DataOptions.ENVIRONMENT_TEMP): DataFunction("_get_env_temp"),
+        str(DataOptions.ENVIRONMENT_TEMP): DataFunction("get_env_temp"),
        str(DataOptions.WATTAGE): DataFunction(
-            "_get_wattage",
+            "get_wattage",
            [
                WebAPICommand("web_get_all", "getAll"),
                RPCAPICommand("api_stats", "stats"),
            ],
        ),
        str(DataOptions.WATTAGE_LIMIT): DataFunction(
-            "_get_wattage_limit",
+            "get_wattage_limit",
            [
                WebAPICommand("web_get_all", "getAll"),
            ],
        ),
        str(DataOptions.FANS): DataFunction(
-            "_get_fans",
+            "get_fans",
            [
                WebAPICommand("web_get_all", "getAll"),
            ],
        ),
-        str(DataOptions.FAN_PSU): DataFunction("_get_fan_psu"),
+        str(DataOptions.FAN_PSU): DataFunction("get_fan_psu"),
        str(DataOptions.ERRORS): DataFunction(
-            "_get_errors",
+            "get_errors",
            [
                WebAPICommand("web_get_error_detail", "getErrorDetail"),
            ],
        ),
-        str(DataOptions.FAULT_LIGHT): DataFunction("_get_fault_light"),
-        str(DataOptions.IS_MINING): DataFunction("_is_mining"),
+        str(DataOptions.FAULT_LIGHT): DataFunction("get_fault_light"),
+        str(DataOptions.IS_MINING): DataFunction("is_mining"),
        str(DataOptions.UPTIME): DataFunction(
-            "_get_uptime", [RPCAPICommand("api_stats", "stats")]
+            "get_uptime", [RPCAPICommand("api_stats", "stats")]
        ),
        str(DataOptions.CONFIG): DataFunction("get_config"),
    }
@@ -175,7 +176,7 @@ class Innosilicon(CGMiner):
    ### DATA GATHERING FUNCTIONS (get_{some_data}) ###
    ##################################################

-    async def _get_mac(
+    async def get_mac(
        self, web_get_all: dict = None, web_overview: dict = None
    ) -> Optional[str]:
        if web_get_all:
@@ -201,7 +202,7 @@ class Innosilicon(CGMiner):
            except KeyError:
                pass

-    async def _get_hashrate(
+    async def get_hashrate(
        self, api_summary: dict = None, web_get_all: dict = None
    ) -> Optional[float]:
        if web_get_all:
@@ -233,7 +234,7 @@ class Innosilicon(CGMiner):
            except (KeyError, IndexError):
                pass

-    async def _get_hashboards(
+    async def get_hashboards(
        self, api_stats: dict = None, web_get_all: dict = None
    ) -> List[HashBoard]:
        if web_get_all:
@@ -291,7 +292,7 @@ class Innosilicon(CGMiner):

        return hashboards

-    async def _get_wattage(
+    async def get_wattage(
        self, web_get_all: dict = None, api_stats: dict = None
    ) -> Optional[int]:
        if web_get_all:
@@ -328,7 +329,7 @@ class Innosilicon(CGMiner):
                        wattage = int(wattage)
                        return wattage

-    async def _get_fans(self, web_get_all: dict = None) -> List[Fan]:
+    async def get_fans(self, web_get_all: dict = None) -> List[Fan]:
        if web_get_all:
            web_get_all = web_get_all["all"]

@@ -353,7 +354,7 @@ class Innosilicon(CGMiner):

        return fans

-    async def _get_errors(
+    async def get_errors(
        self, web_get_error_detail: dict = None
    ) -> List[MinerErrorData]:
        errors = []
@@ -376,7 +377,7 @@ class Innosilicon(CGMiner):
                    errors.append(InnosiliconError(error_code=err))
        return errors

-    async def _get_wattage_limit(self, web_get_all: dict = None) -> Optional[int]:
+    async def get_wattage_limit(self, web_get_all: dict = None) -> Optional[int]:
        if web_get_all:
            web_get_all = web_get_all["all"]

@@ -399,5 +400,5 @@ class Innosilicon(CGMiner):
                limit = 1250 + (250 * level)
                return limit

-    async def _get_expected_hashrate(self) -> Optional[float]:
+    async def get_expected_hashrate(self) -> Optional[float]:
        pass
--- a/tests/miners_tests/init.py
+++ b/tests/miners_tests/init.py
@@ -13,13 +13,16 @@
 #  See the License for the specific language governing permissions and         -
 #  limitations under the License.                                              -
 # ------------------------------------------------------------------------------
+import asyncio
 import inspect
+import sys
 import unittest
 import warnings
 from dataclasses import asdict

 from pyasic.miners.backends import CGMiner  # noqa
-from pyasic.miners.miner_factory import MINER_CLASSES
+from pyasic.miners.base import BaseMiner
+from pyasic.miners.miner_factory import MINER_CLASSES, MinerFactory


 class MinersTest(unittest.TestCase):
@@ -28,7 +31,7 @@ class MinersTest(unittest.TestCase):
        for miner_model in MINER_CLASSES.keys():
            for miner_api in MINER_CLASSES[miner_model].keys():
                with self.subTest(
-                    msg=f"Test creation of miner",
+                    msg=f"Creation of miner using model={miner_model}, api={miner_api}",
                    miner_model=miner_model,
                    miner_api=miner_api,
                ):
@@ -53,6 +56,7 @@ class MinersTest(unittest.TestCase):
                "hostname",
                "is_mining",
                "mac",
+                "model",
                "expected_hashrate",
                "uptime",
                "wattage",
@@ -63,7 +67,7 @@ class MinersTest(unittest.TestCase):
        for miner_model in MINER_CLASSES.keys():
            for miner_api in MINER_CLASSES[miner_model].keys():
                with self.subTest(
-                    msg=f"Data map key check",
+                    msg=f"Data map key check of miner using model={miner_model}, api={miner_api}",
                    miner_model=miner_model,
                    miner_api=miner_api,
                ):
@@ -80,7 +84,7 @@ class MinersTest(unittest.TestCase):
                miner = MINER_CLASSES[miner_model][miner_api]("127.0.0.1")
                for data_point in asdict(miner.data_locations).values():
                    with self.subTest(
-                        msg=f"Test {data_point['cmd']} signature matches",
+                        msg=f"Test {data_point['cmd']} signature matches with model={miner_model}, api={miner_api}",
                        miner_model=miner_model,
                        miner_api=miner_api,
                    ):
@@ -98,22 +102,6 @@ class MinersTest(unittest.TestCase):
                            set([k["name"] for k in data_point["kwargs"]]),
                        )

-    def test_data_locations_use_private_funcs(self):
-        warnings.filterwarnings("ignore")
-        for miner_model in MINER_CLASSES.keys():
-            for miner_api in MINER_CLASSES[miner_model].keys():
-                miner = MINER_CLASSES[miner_model][miner_api]("127.0.0.1")
-                for data_point in asdict(miner.data_locations).values():
-                    with self.subTest(
-                        msg=f"Test {data_point['cmd']} is private",
-                        miner_model=miner_model,
-                        miner_api=miner_api,
-                    ):
-                        self.assertTrue(
-                            data_point["cmd"].startswith("_")
-                            or data_point["cmd"] == "get_config"
-                        )
-

 if __name__ == "__main__":
    unittest.main()