Add support for HS300 power strip (#137)

* discover runs, prints on since of device 0 * added preliminary support for HS300 * forgot to add smartdevice to commit * added index to CLI * clean up dirty code * added fake sysinfo_hs300 * changed device alias to match MAC * #131 Move _id_to_index into smartstrip so everyone can pass index * Update pyHS100/discover.py Co-Authored-By: jimboca <jimboca3@gmail.com> * refactoring to deduplicate code between smarplug and smartstrip * fixing CI failures for devices without children * incorporating feedback from pull request. * fixing hound violation * changed internal store from list of dicts to dict * changed other methods to dictionary store as well * removed unused optional type from imports * changed plugs to Dict, remove redundant sys_info calls * added more functionality for smart strip, added smart strip tests * updated FakeTransportProtocol for devices with children * corrected hound violations * add click-datetime
2025-10-12 10:28:01 +00:00 · 2019-01-08 11:13:25 -08:00
parent ae53e8de1e
commit 6115d96c39
12 changed files with 1035 additions and 39 deletions
--- a/pyHS100/tests/fakes.py
+++ b/pyHS100/tests/fakes.py
@@ -5,35 +5,42 @@ import logging

 _LOGGER = logging.getLogger(__name__)

-def get_realtime(obj, x):
+
+def get_realtime(obj, x, child_ids=[]):
    return {"current":0.268587,"voltage":125.836131,"power":33.495623,"total":0.199000}

-def get_monthstat(obj, x):
+
+def get_monthstat(obj, x, child_ids=[]):
    if x["year"] < 2016:
        return {"month_list":[]}

    return {"month_list": [{"year": 2016, "month": 11, "energy": 1.089000}, {"year": 2016, "month": 12, "energy": 1.582000}]}

-def get_daystat(obj, x):
+
+def get_daystat(obj, x, child_ids=[]):
    if x["year"] < 2016:
        return {"day_list":[]}

    return {"day_list": [{"year": 2016, "month": 11, "day": 24, "energy": 0.026000},
                  {"year": 2016, "month": 11, "day": 25, "energy": 0.109000}]}

+
 emeter_support = {"get_realtime": get_realtime,
                  "get_monthstat": get_monthstat,
                  "get_daystat": get_daystat,}

+
 def get_realtime_units(obj, x):
    return {"power_mw": 10800}

+
 def get_monthstat_units(obj, x):
    if x["year"] < 2016:
        return {"month_list":[]}

    return {"month_list": [{"year": 2016, "month": 11, "energy_wh": 32}, {"year": 2016, "month": 12, "energy_wh": 16}]}

+
 def get_daystat_units(obj, x):
    if x["year"] < 2016:
        return {"day_list":[]}
@@ -41,10 +48,91 @@ def get_daystat_units(obj, x):
    return {"day_list": [{"year": 2016, "month": 11, "day": 24, "energy_wh": 20},
                  {"year": 2016, "month": 11, "day": 25, "energy_wh": 32}]}

+
 emeter_units_support = {"get_realtime": get_realtime_units,
                        "get_monthstat": get_monthstat_units,
                        "get_daystat": get_daystat_units,}

+sysinfo_hs300 = {
+    'system': {
+        'get_sysinfo': {
+            'sw_ver': '1.0.6 Build 180627 Rel.081000',
+            'hw_ver': '1.0',
+            'model': 'HS300(US)',
+            'deviceId': '7003ADE7030B7EFADE747104261A7A70931DADF4',
+            'oemId': 'FFF22CFF774A0B89F7624BFC6F50D5DE',
+            'hwId': '22603EA5E716DEAEA6642A30BE87AFCB',
+            'rssi': -53,
+            'longitude_i': -1198698,
+            'latitude_i': 352737,
+            'alias': 'TP-LINK_Power Strip_2233',
+            'mic_type': 'IOT.SMARTPLUGSWITCH',
+            'feature': 'TIM:ENE',
+            'mac': '50:C7:BF:11:22:33',
+            'updating': 0,
+            'led_off': 0,
+            'children': [
+                {
+                    'id': '7003ADE7030B7EFADE747104261A7A70931DADF400',
+                    'state': 1,
+                    'alias': 'my plug 1 device',
+                    'on_time': 5423,
+                    'next_action': {
+                        'type': -1
+                    }
+                },
+                {
+                    'id': '7003ADE7030B7EFADE747104261A7A70931DADF401',
+                    'state': 1,
+                    'alias': 'my plug 2 device',
+                    'on_time': 4750,
+                    'next_action': {
+                        'type': -1
+                    }
+                },
+                {
+                    'id': '7003ADE7030B7EFADE747104261A7A70931DADF402',
+                    'state': 1,
+                    'alias': 'my plug 3 device',
+                    'on_time': 4748,
+                    'next_action': {
+                        'type': -1
+                    }
+                },
+                {
+                    'id': '7003ADE7030B7EFADE747104261A7A70931DADF403',
+                    'state': 1,
+                    'alias': 'my plug 4 device',
+                    'on_time': 4742,
+                    'next_action': {
+                        'type': -1
+                    }
+                },
+                {
+                    'id': '7003ADE7030B7EFADE747104261A7A70931DADF404',
+                    'state': 1,
+                    'alias': 'my plug 5 device',
+                    'on_time': 4745,
+                    'next_action': {
+                        'type': -1
+                    }
+                },
+                {
+                    'id': '7003ADE7030B7EFADE747104261A7A70931DADF405',
+                    'state': 1,
+                    'alias': 'my plug 6 device',
+                    'on_time': 5028,
+                    'next_action': {
+                        'type': -1
+                    }
+                }
+            ],
+            'child_num': 6,
+            'err_code': 0
+        }
+    }
+}
+
 sysinfo_hs100 = {'system': {'get_sysinfo':
                                {'active_mode': 'schedule',
                                 'alias': 'My Smart Plug',
@@ -484,13 +572,28 @@ class FakeTransportProtocol(TPLinkSmartHomeProtocol):
        self.proto = proto
        self.invalid = invalid

-    def set_alias(self, x):
+    def set_alias(self, x, child_ids=[]):
        _LOGGER.debug("Setting alias to %s", x["alias"])
-        self.proto["system"]["get_sysinfo"]["alias"] = x["alias"]
+        if child_ids:
+            for child in self.proto["system"]["get_sysinfo"]["children"]:
+                if child["id"] in child_ids:
+                    child["alias"] = x["alias"]
+        else:
+            self.proto["system"]["get_sysinfo"]["alias"] = x["alias"]

-    def set_relay_state(self, x):
-        _LOGGER.debug("Setting relay state to %s", x)
-        self.proto["system"]["get_sysinfo"]["relay_state"] = x["state"]
+    def set_relay_state(self, x, child_ids=[]):
+        _LOGGER.debug("Setting relay state to %s", x["state"])
+
+        if not child_ids and "children" in self.proto["system"]["get_sysinfo"]:
+            for child in self.proto["system"]["get_sysinfo"]["children"]:
+                child_ids.append(child["id"])
+
+        if child_ids:
+            for child in self.proto["system"]["get_sysinfo"]["children"]:
+                if child["id"] in child_ids:
+                    child["state"] = x["state"]
+        else:
+            self.proto["system"]["get_sysinfo"]["relay_state"] = x["state"]

    def set_led_off(self, x):
        _LOGGER.debug("Setting led off to %s", x)
@@ -516,6 +619,7 @@ class FakeTransportProtocol(TPLinkSmartHomeProtocol):
                    "get_dev_icon": {"icon": None, "hash": None},
                    "set_mac_addr": set_mac,
                    "get_sysinfo": None,
+                    "context": None,
        },
        "emeter": { "get_realtime": None,
                    "get_daystat": None,
@@ -537,14 +641,24 @@ class FakeTransportProtocol(TPLinkSmartHomeProtocol):
        # HS220 brightness, different setter and getter
        "smartlife.iot.dimmer": { "set_brightness": set_hs220_brightness,
        },
+        "context": {"child_ids": None},
    }

    def query(self, host, request, port=9999):
        if self.invalid:
            raise SmartDeviceException("Invalid connection, can't query!")

+        _LOGGER.debug("Requesting {} from {}:{}".format(request, host, port))
+
        proto = self.proto

+        # collect child ids from context
+        try:
+            child_ids = request["context"]["child_ids"]
+            request.pop("context", None)
+        except KeyError:
+            child_ids = []
+
        target = next(iter(request))
        if target not in proto.keys():
            return error(target, msg="target not found")
@@ -557,7 +671,10 @@ class FakeTransportProtocol(TPLinkSmartHomeProtocol):
        _LOGGER.debug("Going to execute {}.{} (params: {}).. ".format(target, cmd, params))

        if callable(proto[target][cmd]):
-            res = proto[target][cmd](self, params)
+            if child_ids:
+                res = proto[target][cmd](self, params, child_ids)
+            else:
+                res = proto[target][cmd](self, params)
            # verify that change didn't break schema, requires refactoring..
            #TestSmartPlug.sysinfo_schema(self.proto["system"]["get_sysinfo"])
            return success(target, cmd, res)
--- a/pyHS100/tests/test_pyHS100.py
+++ b/pyHS100/tests/test_pyHS100.py
@@ -84,7 +84,7 @@ class TestSmartPlugHS100(TestCase):
        'total': Any(Coerce(float, Range(min=0)), None),
        'current': Any(All(float, Range(min=0)), None),

-        'voltage_mw': Any(All(float, Range(min=0, max=300000)), None),
+        'voltage_mv': Any(All(float, Range(min=0, max=300000)), None),
        'power_mw': Any(Coerce(float, Range(min=0)), None),
        'total_wh': Any(Coerce(float, Range(min=0)), None),
        'current_ma': Any(All(float, Range(min=0)), None),
--- a/pyHS100/tests/test_strip.py
+++ b/pyHS100/tests/test_strip.py
@@ -0,0 +1,438 @@
+from unittest import TestCase, skip
+from voluptuous import Schema, All, Any, Range, Coerce
+import datetime
+
+from .. import SmartStrip, SmartPlug, SmartStripException, SmartDeviceException
+from .fakes import FakeTransportProtocol, sysinfo_hs300
+from .test_pyHS100 import check_mac, check_int_bool
+
+# Set IP instead of None if you want to run tests on a device.
+STRIP_IP = None
+
+
+class TestSmartStripHS300(TestCase):
+    SYSINFO = sysinfo_hs300  # type: Dict
+    # these schemas should go to the mainlib as
+    # they can be useful when adding support for new features/devices
+    # as well as to check that faked devices are operating properly.
+    sysinfo_schema = Schema({
+        "sw_ver": str,
+        "hw_ver": str,
+        "model": str,
+        "deviceId": str,
+        "oemId": str,
+        "hwId": str,
+        "rssi": Any(int, None),  # rssi can also be positive, see #54
+        "longitude": Any(All(int, Range(min=-1800000, max=1800000)), None),
+        "latitude": Any(All(int, Range(min=-900000, max=900000)), None),
+        "longitude_i": Any(All(int, Range(min=-1800000, max=1800000)), None),
+        "latitude_i": Any(All(int, Range(min=-900000, max=900000)), None),
+        "alias": str,
+        "mic_type": str,
+        "feature": str,
+        "mac": check_mac,
+        "updating": check_int_bool,
+        "led_off": check_int_bool,
+        "children": [{
+            "id": str,
+            "state": int,
+            "alias": str,
+            "on_time": int,
+            "next_action": {"type": int},
+        }],
+        "child_num": int,
+        "err_code": int,
+    })
+
+    current_consumption_schema = Schema(
+        Any(
+            {
+                "voltage": Any(All(float, Range(min=0, max=300)), None),
+                "power": Any(Coerce(float, Range(min=0)), None),
+                "total": Any(Coerce(float, Range(min=0)), None),
+                "current": Any(All(float, Range(min=0)), None),
+
+                "voltage_mv": Any(All(int, Range(min=0, max=300000)), None),
+                "power_mw": Any(Coerce(int, Range(min=0)), None),
+                "total_wh": Any(Coerce(int, Range(min=0)), None),
+                "current_ma": Any(All(int, Range(min=0)), None),
+            },
+            None
+        )
+    )
+
+    tz_schema = Schema({
+        "zone_str": str,
+        "dst_offset": int,
+        "index": All(int, Range(min=0)),
+        "tz_str": str,
+    })
+
+    def setUp(self):
+        if STRIP_IP is not None:
+            self.strip = SmartStrip(STRIP_IP)
+        else:
+            self.strip = SmartStrip(
+                host="127.0.0.1",
+                protocol=FakeTransportProtocol(self.SYSINFO)
+            )
+
+    def tearDown(self):
+        self.strip = None
+
+    def test_initialize(self):
+        self.assertIsNotNone(self.strip.sys_info)
+        self.assertTrue(self.strip.num_children)
+        self.sysinfo_schema(self.strip.sys_info)
+
+    def test_initialize_invalid_connection(self):
+        with self.assertRaises(SmartDeviceException):
+            SmartStrip(
+                host="127.0.0.1",
+                protocol=FakeTransportProtocol(self.SYSINFO, invalid=True))
+
+    def test_query_helper(self):
+        with self.assertRaises(SmartDeviceException):
+            self.strip._query_helper("test", "testcmd", {})
+
+    def test_raise_for_index(self):
+        with self.assertRaises(SmartStripException):
+            self.strip.raise_for_index(index=self.strip.num_children + 100)
+
+    def test_state_strip(self):
+        with self.assertRaises(ValueError):
+            self.strip.state = 1234
+        with self.assertRaises(ValueError):
+            self.strip.state = "1234"
+        with self.assertRaises(ValueError):
+            self.strip.state = True
+
+        orig_state = self.strip.state
+        if orig_state == SmartPlug.SWITCH_STATE_OFF:
+            self.strip.state = "ON"
+            self.assertTrue(self.strip.state == SmartPlug.SWITCH_STATE_ON)
+            self.strip.state = "OFF"
+            self.assertTrue(self.strip.state == SmartPlug.SWITCH_STATE_OFF)
+        elif orig_state == SmartPlug.SWITCH_STATE_ON:
+            self.strip.state = "OFF"
+            self.assertTrue(self.strip.state == SmartPlug.SWITCH_STATE_OFF)
+            self.strip.state = "ON"
+            self.assertTrue(self.strip.state == SmartPlug.SWITCH_STATE_ON)
+        elif orig_state == SmartPlug.SWITCH_STATE_UNKNOWN:
+            self.fail("can't test for unknown state")
+
+    def test_state_plugs(self):
+        # value errors
+        for plug_index in range(self.strip.num_children):
+            with self.assertRaises(ValueError):
+                self.strip.set_state(value=1234, index=plug_index)
+
+            with self.assertRaises(ValueError):
+                self.strip.set_state(value="1234", index=plug_index)
+
+            with self.assertRaises(ValueError):
+                self.strip.set_state(value=True, index=plug_index)
+
+        # out of bounds error
+        with self.assertRaises(SmartStripException):
+            self.strip.set_state(
+                value=SmartPlug.SWITCH_STATE_ON,
+                index=self.strip.num_children + 100
+            )
+
+        # on off
+        for plug_index in range(self.strip.num_children):
+            orig_state = self.strip.state[plug_index]
+            if orig_state == SmartPlug.SWITCH_STATE_OFF:
+                self.strip.set_state(value="ON", index=plug_index)
+                self.assertTrue(
+                    self.strip.state[plug_index] == SmartPlug.SWITCH_STATE_ON)
+                self.strip.set_state(value="OFF", index=plug_index)
+                self.assertTrue(
+                    self.strip.state[plug_index] == SmartPlug.SWITCH_STATE_OFF)
+            elif orig_state == SmartPlug.SWITCH_STATE_ON:
+                self.strip.set_state(value="OFF", index=plug_index)
+                self.assertTrue(
+                    self.strip.state[plug_index] == SmartPlug.SWITCH_STATE_OFF)
+                self.strip.set_state(value="ON", index=plug_index)
+                self.assertTrue(
+                    self.strip.state[plug_index] == SmartPlug.SWITCH_STATE_ON)
+            elif orig_state == SmartPlug.SWITCH_STATE_UNKNOWN:
+                self.fail("can't test for unknown state")
+
+    def test_turns_and_isses(self):
+        # all on
+        self.strip.turn_on()
+        for index, state in self.strip.is_on().items():
+            self.assertTrue(state)
+            self.assertTrue(self.strip.is_on(index=index) == state)
+
+        # all off
+        self.strip.turn_off()
+        for index, state in self.strip.is_on().items():
+            self.assertFalse(state)
+            self.assertTrue(self.strip.is_on(index=index) == state)
+
+        # individual on
+        for plug_index in range(self.strip.num_children):
+            original_states = self.strip.is_on()
+            self.strip.turn_on(index=plug_index)
+
+            # only target outlet should have state changed
+            for index, state in self.strip.is_on().items():
+                if index == plug_index:
+                    self.assertTrue(state != original_states[index])
+                else:
+                    self.assertTrue(state == original_states[index])
+
+        # individual off
+        for plug_index in range(self.strip.num_children):
+            original_states = self.strip.is_on()
+            self.strip.turn_off(index=plug_index)
+
+            # only target outlet should have state changed
+            for index, state in self.strip.is_on().items():
+                if index == plug_index:
+                    self.assertTrue(state != original_states[index])
+                else:
+                    self.assertTrue(state == original_states[index])
+
+        # out of bounds
+        with self.assertRaises(SmartStripException):
+            self.strip.turn_off(index=self.strip.num_children + 100)
+        with self.assertRaises(SmartStripException):
+            self.strip.turn_on(index=self.strip.num_children + 100)
+        with self.assertRaises(SmartStripException):
+            self.strip.is_on(index=self.strip.num_children + 100)
+
+    @skip("this test will wear out your relays")
+    def test_all_binary_states(self):
+        # test every binary state
+        for state in range(2 ** self.strip.num_children):
+
+            # create binary state map
+            state_map = {}
+            for plug_index in range(self.strip.num_children):
+                state_map[plug_index] = bool((state >> plug_index) & 1)
+
+                if state_map[plug_index]:
+                    self.strip.turn_on(index=plug_index)
+                else:
+                    self.strip.turn_off(index=plug_index)
+
+            # check state map applied
+            for index, state in self.strip.is_on().items():
+                self.assertTrue(state_map[index] == state)
+
+            # toggle each outlet with state map applied
+            for plug_index in range(self.strip.num_children):
+
+                # toggle state
+                if state_map[plug_index]:
+                    self.strip.turn_off(index=plug_index)
+                else:
+                    self.strip.turn_on(index=plug_index)
+
+                # only target outlet should have state changed
+                for index, state in self.strip.is_on().items():
+                    if index == plug_index:
+                        self.assertTrue(state != state_map[index])
+                    else:
+                        self.assertTrue(state == state_map[index])
+
+                # reset state
+                if state_map[plug_index]:
+                    self.strip.turn_on(index=plug_index)
+                else:
+                    self.strip.turn_off(index=plug_index)
+
+                # original state map should be restored
+                for index, state in self.strip.is_on().items():
+                    self.assertTrue(state == state_map[index])
+
+    def test_has_emeter(self):
+        # a not so nice way for checking for emeter availability..
+        if "HS300" in self.strip.sys_info["model"]:
+            self.assertTrue(self.strip.has_emeter)
+        else:
+            self.assertFalse(self.strip.has_emeter)
+
+    def test_get_emeter_realtime(self):
+        if self.strip.has_emeter:
+            # test with index
+            for plug_index in range(self.strip.num_children):
+                emeter = self.strip.get_emeter_realtime(index=plug_index)
+                self.current_consumption_schema(emeter)
+
+            # test without index
+            for index, emeter in self.strip.get_emeter_realtime().items():
+                self.current_consumption_schema(emeter)
+
+            # out of bounds
+            with self.assertRaises(SmartStripException):
+                self.strip.get_emeter_realtime(
+                    index=self.strip.num_children + 100
+                )
+        else:
+            self.assertEqual(self.strip.get_emeter_realtime(), None)
+
+    def test_get_emeter_daily(self):
+        if self.strip.has_emeter:
+            # test with index
+            for plug_index in range(self.strip.num_children):
+                emeter = self.strip.get_emeter_daily(year=1900, month=1,
+                                                     index=plug_index)
+                self.assertEqual(emeter, {})
+                if len(emeter) < 1:
+                    print("no emeter daily information, skipping..")
+                    return
+                k, v = emeter.popitem()
+                self.assertTrue(isinstance(k, int))
+                self.assertTrue(isinstance(v, float))
+
+            # test without index
+            all_emeter = self.strip.get_emeter_daily(year=1900, month=1)
+            for index, emeter in all_emeter.items():
+                self.assertEqual(emeter, {})
+                if len(emeter) < 1:
+                    print("no emeter daily information, skipping..")
+                    return
+                k, v = emeter.popitem()
+                self.assertTrue(isinstance(k, int))
+                self.assertTrue(isinstance(v, float))
+
+            # out of bounds
+            with self.assertRaises(SmartStripException):
+                self.strip.get_emeter_daily(
+                    year=1900,
+                    month=1,
+                    index=self.strip.num_children + 100
+                )
+        else:
+            self.assertEqual(
+                self.strip.get_emeter_daily(year=1900, month=1), None)
+
+    def test_get_emeter_monthly(self):
+        if self.strip.has_emeter:
+            # test with index
+            for plug_index in range(self.strip.num_children):
+                emeter = self.strip.get_emeter_monthly(year=1900,
+                                                       index=plug_index)
+                self.assertEqual(emeter, {})
+                if len(emeter) < 1:
+                    print("no emeter daily information, skipping..")
+                    return
+                k, v = emeter.popitem()
+                self.assertTrue(isinstance(k, int))
+                self.assertTrue(isinstance(v, float))
+
+            # test without index
+            all_emeter = self.strip.get_emeter_monthly(year=1900)
+            for index, emeter in all_emeter.items():
+                self.assertEqual(emeter, {})
+                if len(emeter) < 1:
+                    print("no emeter daily information, skipping..")
+                    return
+                k, v = emeter.popitem()
+                self.assertTrue(isinstance(k, int))
+                self.assertTrue(isinstance(v, float))
+
+            # out of bounds
+            with self.assertRaises(SmartStripException):
+                self.strip.get_emeter_monthly(
+                    year=1900,
+                    index=self.strip.num_children + 100
+                )
+        else:
+            self.assertEqual(self.strip.get_emeter_monthly(year=1900), None)
+
+    @skip("not clearing your stats..")
+    def test_erase_emeter_stats(self):
+        self.fail()
+
+    def test_current_consumption(self):
+        if self.strip.has_emeter:
+            # test with index
+            for plug_index in range(self.strip.num_children):
+                emeter = self.strip.current_consumption(index=plug_index)
+                self.assertTrue(isinstance(emeter, float))
+                self.assertTrue(emeter >= 0.0)
+
+            # test without index
+            for index, emeter in self.strip.current_consumption().items():
+                self.assertTrue(isinstance(emeter, float))
+                self.assertTrue(emeter >= 0.0)
+
+            # out of bounds
+            with self.assertRaises(SmartStripException):
+                self.strip.current_consumption(
+                    index=self.strip.num_children + 100
+                )
+        else:
+            self.assertEqual(self.strip.current_consumption(), None)
+
+    def test_alias(self):
+        test_alias = "TEST1234"
+
+        # strip alias
+        original = self.strip.alias
+        self.assertTrue(isinstance(original, str))
+        self.strip.alias = test_alias
+        self.assertEqual(self.strip.alias, test_alias)
+        self.strip.alias = original
+        self.assertEqual(self.strip.alias, original)
+
+        # plug alias
+        original = self.strip.get_alias()
+        for plug in range(self.strip.num_children):
+            self.strip.set_alias(alias=test_alias, index=plug)
+            self.assertEqual(self.strip.get_alias(index=plug), test_alias)
+            self.strip.set_alias(alias=original[plug], index=plug)
+            self.assertEqual(self.strip.get_alias(index=plug), original[plug])
+
+    def test_led(self):
+        original = self.strip.led
+
+        self.strip.led = False
+        self.assertFalse(self.strip.led)
+        self.strip.led = True
+        self.assertTrue(self.strip.led)
+        self.strip.led = original
+
+    def test_icon(self):
+        with self.assertRaises(NotImplementedError):
+            self.strip.icon
+
+    def test_time(self):
+        self.assertTrue(isinstance(self.strip.time, datetime.datetime))
+        # TODO check setting?
+
+    def test_timezone(self):
+        self.tz_schema(self.strip.timezone)
+
+    def test_hw_info(self):
+        self.sysinfo_schema(self.strip.hw_info)
+
+    def test_on_since(self):
+        # out of bounds
+        with self.assertRaises(SmartStripException):
+            self.strip.on_since(index=self.strip.num_children + 1)
+
+        # individual on_since
+        for plug_index in range(self.strip.num_children):
+            self.assertTrue(isinstance(
+                self.strip.on_since(index=plug_index), datetime.datetime))
+
+        # all on_since
+        for index, plug_on_since in self.strip.on_since().items():
+            self.assertTrue(isinstance(plug_on_since, datetime.datetime))
+
+    def test_location(self):
+        print(self.strip.location)
+        self.sysinfo_schema(self.strip.location)
+
+    def test_rssi(self):
+        self.sysinfo_schema({'rssi': self.strip.rssi})  # wrapping for vol
+
+    def test_mac(self):
+        self.sysinfo_schema({'mac': self.strip.mac})  # wrapping for vol