class TestHtParams:
@pytest.mark.parametrize("name, acl", [(name, param.acl) for name, param in HtParams.items()])
def test_acl(self, name, acl):
assert acl is not None, "acl must not be None"
m = re.match("^(r-|-w|rw)$", acl)
assert m is not None, "invalid acl definition for parameter {!r} [{!r}]".format(name, acl)
#assert 0
@pytest.mark.parametrize("name, min, max", [(name, param.min, param.max) for name, param in HtParams.items()])
def test_limits(self, name, min, max):
assert min is not None, "minimal value for parameter {!r} must not be None".format(name)
assert max is not None, "maximal value for parameter {!r} must not be None".format(name)
assert min <= max
assert max >= min
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.parametrize("name, param", [(name, param) for name, param in HtParams.items()])
def test_validate_param(self, hthp, name, param):
hthp.send_request(param.cmd())
resp = hthp.read_response()
m = re.match("^{},.*NAME=([^,]+).*VAL=([^,]+).*MAX=([^,]+).*MIN=([^,]+).*$".format(param.cmd()), resp)
assert m is not None, "invalid response for query of parameter {!r} [{!r}]".format(name, resp)
dp_name = m.group(1).strip()
assert dp_name == name,\
"data point name doesn't match with the parameter name {!r} [{!r}]".format(name, dp_name)
dp_value = param.from_str(m.group(2))
assert dp_value is not None, "data point value must not be None [{}]".format(dp_value)
dp_max = param.from_str(m.group(3))
assert dp_max == param.max,\
"data point max value doesn't match with the parameter's one {!s} [{!s}]".format(param.max, dp_max)
dp_min = param.from_str(m.group(4))
assert dp_min == param.min,\
"data point min value doesn't match with the parameter's one {!s} [{!s}]".format(param.min, dp_min)
class TestHtParams:
@pytest.mark.parametrize("name, acl",
[(name, param.acl)
for name, param in HtParams.items()])
def test_acl(self, name: str, acl: str):
assert acl is not None, "'acl' must not be None"
m = re.match(r"^(r-|-w|rw)$", acl)
assert m is not None, "invalid acl definition for parameter {!r} [{!r}]".format(
name, acl)
#assert 0
@pytest.mark.parametrize("name, min_val, max_val",
[(name, param.min_val, param.max_val)
for name, param in HtParams.items()])
def test_limits(self, name: str, min_val: HtParamValueType,
max_val: HtParamValueType):
assert min_val is not None, "minimal value for parameter {!r} must not be None".format(
name)
assert max_val is not None, "maximal value for parameter {!r} must not be None".format(
name)
assert min_val <= max_val
assert max_val >= min_val
#assert 0
@pytest.mark.parametrize("name, param", HtParams.items())
def test_get(self, name: str, param: HtParam):
assert HtParams.get(name) == param
#assert 0
def test_dump(self):
assert HtParams.dump() is None
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
@pytest.mark.parametrize("name, param", HtParams.items())
def test_validate_param(self, hthp: HtHeatpump, name: str, param: HtParam):
hthp.send_request(param.cmd())
resp = hthp.read_response()
m = re.match(
r"^{},.*NAME=([^,]+).*VAL=([^,]+).*MAX=([^,]+).*MIN=([^,]+).*$".
format(param.cmd()), resp)
assert m is not None, "invalid response for query of parameter {!r} [{!r}]".format(
name, resp)
dp_name = m.group(1).strip()
assert dp_name == name,\
"data point name doesn't match with the parameter name {!r} [{!r}]".format(name, dp_name)
dp_value = param.from_str(m.group(2))
assert dp_value is not None, "data point value must not be None [{}]".format(
dp_value)
dp_max = param.from_str(m.group(3))
assert dp_max == param.max_val,\
"data point max value doesn't match with the parameter's one {!s} [{!s}]".format(param.max_val, dp_max)
dp_min = param.from_str(m.group(4))
if name == "Verdichter laeuft seit" and dp_min == 10:
dp_min = 0 # seems to be incorrect for the data point "Verdichter laeuft seit" [10 == 0]
assert dp_min == param.min_val,\
"data point min value doesn't match with the parameter's one {!s} [{!s}]".format(param.min_val, dp_min)
class TestHtParam:
@pytest.mark.parametrize(
"s, data_type, exp_value, strict",
[
("0", HtDataTypes.BOOL, False, False),
("1", HtDataTypes.BOOL, True, False),
("123", HtDataTypes.INT, 123, False),
("-321", HtDataTypes.INT, -321, False),
("123.456", HtDataTypes.FLOAT, 123.456, False),
("-321.456", HtDataTypes.FLOAT, -321.456, False),
("789", HtDataTypes.FLOAT, 789.0, False),
# -- should raise a 'ValueError':
("True", HtDataTypes.BOOL, None, False),
("False", HtDataTypes.BOOL, None, False),
("true", HtDataTypes.BOOL, None, False),
("false", HtDataTypes.BOOL, None, False),
("yes", HtDataTypes.BOOL, None, False),
("no", HtDataTypes.BOOL, None, False),
("y", HtDataTypes.BOOL, None, False),
("n", HtDataTypes.BOOL, None, False),
("TRUE", HtDataTypes.BOOL, None, False),
("FALSE", HtDataTypes.BOOL, None, False),
("YES", HtDataTypes.BOOL, None, False),
("NO", HtDataTypes.BOOL, None, False),
("Y", HtDataTypes.BOOL, None, False),
("N", HtDataTypes.BOOL, None, False),
("abc", HtDataTypes.BOOL, None, False),
("def", HtDataTypes.INT, None, False),
("--99", HtDataTypes.INT, None, False),
("12+55", HtDataTypes.INT, None, False),
("ghi", HtDataTypes.FLOAT, None, False),
("--99.0", HtDataTypes.FLOAT, None, False),
("12.3+55.9", HtDataTypes.FLOAT, None, False),
("789", HtDataTypes.FLOAT, None, True),
# ...
])
def test_from_str_static(self, s: str, data_type: HtDataTypes,
exp_value: Optional[HtParamValueType],
strict: bool):
if exp_value is None:
with pytest.raises(ValueError):
HtParam.from_str(s, data_type, strict)
else:
assert HtParam.from_str(s, data_type, strict) == exp_value
#assert 0
def test_from_str_static_assert(self):
with pytest.raises(AssertionError):
HtParam.from_str("", 0)
#assert 0
@pytest.mark.parametrize("param", HtParams.values())
def test_from_str_member(self, param: HtParam):
assert param.from_str(param.to_str(
param.min_val)) == param.min_val # type: ignore
assert param.from_str(param.to_str(
param.max_val)) == param.max_val # type: ignore
#assert 0
@pytest.mark.parametrize(
"val, data_type, exp_str",
[
(False, HtDataTypes.BOOL, "0"),
(True, HtDataTypes.BOOL, "1"),
(123, HtDataTypes.INT, "123"),
(-321, HtDataTypes.INT, "-321"),
(123.456, HtDataTypes.FLOAT, "123.456"),
(-321.456, HtDataTypes.FLOAT, "-321.456"),
(789, HtDataTypes.FLOAT, "789.0"),
(-789, HtDataTypes.FLOAT, "-789.0"),
(789.0, HtDataTypes.FLOAT, "789.0"),
(-789.0, HtDataTypes.FLOAT, "-789.0"),
# ... add some more samples here!
])
def test_to_str_static(self, val: HtParamValueType, data_type: HtDataTypes,
exp_str: str):
assert HtParam.to_str(val, data_type) == exp_str
#assert 0
@pytest.mark.parametrize("param", HtParams.values())
def test_to_str_member(self, param: HtParam):
assert param.to_str(param.min_val) == HtParam.to_str(
param.min_val, param.data_type) # type: ignore
assert param.to_str(param.max_val) == HtParam.to_str(
param.max_val, param.data_type) # type: ignore
#assert 0
@pytest.mark.parametrize("name, param", HtParams.items())
def test_repr(self, name: str, param: HtParam):
assert repr(param) == "HtParam({},{:d},{!r},{}[{},{}])".format(
param.dp_type, param.dp_number, param.acl, param.data_type,
param.min_val, param.max_val)
#assert 0
@pytest.mark.parametrize("name, cmd",
[(name, param.cmd())
for name, param in HtParams.items()])
def test_cmd(self, name: str, cmd: str):
m = re.match(r"^[S|M]P,NR=(\d+)$", cmd)
assert m is not None, "non valid command string for parameter {!r} [{!r}]".format(
name, cmd)
#assert 0
@pytest.mark.parametrize("name, param", HtParams.items())
def test_set_limits(self, name: str, param: HtParam):
assert not param.set_limits(param.min_val, param.max_val)
#assert 0
@pytest.mark.parametrize("name, param", HtParams.items())
def test_in_limits(self, name: str, param: HtParam):
assert param.in_limits(param.min_val)
assert param.in_limits(param.max_val)
#assert 0
@pytest.mark.parametrize("param", HtParams.values())
def test_in_limits_None(self, param: HtParam):
assert param.in_limits(None)
class TestHtHeatpump:
@pytest.mark.run_if_connected
def test_open_connection(self, hthp: HtHeatpump):
assert hthp.is_open
with pytest.raises(IOError):
hthp.open_connection()
#assert 0
@pytest.mark.parametrize("action", [
VerifyAction.NONE(), {VerifyAction.NAME},
{VerifyAction.NAME, VerifyAction.MIN},
{VerifyAction.NAME, VerifyAction.MIN, VerifyAction.MAX},
{
VerifyAction.NAME, VerifyAction.MIN, VerifyAction.MAX,
VerifyAction.VALUE
}, {VerifyAction.MIN, VerifyAction.MAX, VerifyAction.VALUE},
{VerifyAction.MAX, VerifyAction.VALUE}, {VerifyAction.VALUE},
VerifyAction.ALL()
])
def test_verify_param_action(self, cmdopt_device: str,
cmdopt_baudrate: int, action: set):
hp = HtHeatpump(device=cmdopt_device, baudrate=cmdopt_baudrate)
val = hp.verify_param_action
assert isinstance(val, set)
hp.verify_param_action = action
assert hp.verify_param_action == action
hp.verify_param_action = val
#assert 0
def test_verify_param_error(self, cmdopt_device: str,
cmdopt_baudrate: int):
hp = HtHeatpump(device=cmdopt_device, baudrate=cmdopt_baudrate)
val = hp.verify_param_error
assert isinstance(val, bool)
hp.verify_param_error = True
assert hp.verify_param_error is True
hp.verify_param_error = False
assert hp.verify_param_error is False
hp.verify_param_error = val
#assert 0
def test_send_request(self, cmdopt_device: str, cmdopt_baudrate: int):
hp = HtHeatpump(device=cmdopt_device, baudrate=cmdopt_baudrate)
with pytest.raises(IOError):
hp.send_request(r"LIN")
#assert 0
def test_read_response(self, cmdopt_device: str, cmdopt_baudrate: int):
hp = HtHeatpump(device=cmdopt_device, baudrate=cmdopt_baudrate)
with pytest.raises(IOError):
hp.read_response()
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_get_serial_number(self, hthp: HtHeatpump):
rid = hthp.get_serial_number()
assert isinstance(rid, int), "'rid' must be of type int"
assert rid > 0
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_get_version(self, hthp: HtHeatpump):
version = hthp.get_version()
# ( "3.0.20", 2321 )
assert isinstance(version, tuple), "'version' must be of type tuple"
assert len(version) == 2
ver_str, ver_num = version
assert isinstance(ver_str, str), "'ver_str' must be of type str"
m = re.match(r"^(\d+).(\d+).(\d+)$", ver_str)
assert m is not None, "invalid version string [{!r}]".format(ver_str)
assert isinstance(ver_num, int), "'ver_num' must be of type int"
assert ver_num > 0
hthp.send_request(r"SP,NR=9")
resp = hthp.read_response()
m = re.match(r"^SP,NR=9,.*NAME=([^,]+).*VAL=([^,]+).*$", resp)
assert m is not None, "invalid response for query of the software version [{!r}]".format(
resp)
assert ver_str == m.group(1).strip()
assert ver_num == int(m.group(2))
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_get_date_time(self, hthp: HtHeatpump):
date_time = hthp.get_date_time()
# (datetime.datetime(...), 2) # 2 = Tuesday
assert isinstance(date_time,
tuple), "'date_time' must be of type tuple"
assert len(date_time) == 2
dt, weekday = date_time
assert isinstance(dt,
datetime.datetime), "'dt' must be of type datetime"
assert isinstance(weekday, int), "'weekday' must be of type int"
assert weekday in range(1, 8)
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_set_date_time(self, hthp: HtHeatpump):
pass # TODO
#assert 0
def test_set_date_time_raises_TypeError(self, cmdopt_device: str,
cmdopt_baudrate: int):
hp = HtHeatpump(device=cmdopt_device, baudrate=cmdopt_baudrate)
with pytest.raises(TypeError):
hp.set_date_time(123) # type: ignore
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_get_last_fault(self, hthp: HtHeatpump):
fault = hthp.get_last_fault()
# (29, 20, datetime.datetime(...), "EQ_Spreizung")
assert isinstance(fault, tuple), "'fault' must be of type tuple"
assert len(fault) == 4
index, error, dt, msg = fault
assert isinstance(index, int), "'index' must be of type int"
assert 0 <= index < hthp.get_fault_list_size()
assert isinstance(error, int), "'error' must be of type int"
assert error >= 0
assert isinstance(dt,
datetime.datetime), "'dt' must be of type datetime"
assert isinstance(msg, str), "'msg' must be of type str"
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_get_fault_list_size(self, hthp: HtHeatpump):
size = hthp.get_fault_list_size()
assert isinstance(size, int), "'size' must be of type int"
assert size >= 0
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_get_fault_list(self, hthp: HtHeatpump):
fault_list = hthp.get_fault_list()
# [ { "index": 29, # fault list index
# "error": 20, # error code
# "datetime": datetime.datetime(...), # date and time of the entry
# "message": "EQ_Spreizung", # error message
# },
# # ...
# ]
assert isinstance(fault_list,
list), "'fault_list' must be of type list"
for entry in fault_list:
assert isinstance(entry, dict), "'entry' must be of type dict"
index = entry["index"]
assert isinstance(index, int), "'index' must be of type int"
assert 0 <= index < hthp.get_fault_list_size()
error = entry["error"]
assert isinstance(error, int), "'error' must be of type int"
assert error >= 0
dt = entry["datetime"]
assert isinstance(
dt, datetime.datetime), "'dt' must be of type datetime"
msg = entry["message"]
assert isinstance(msg, str), "'msg' must be of type str"
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_get_fault_list_with_index(self, hthp: HtHeatpump):
size = hthp.get_fault_list_size()
assert isinstance(size, int), "'size' must be of type int"
assert size >= 0
for i in range(size):
fault_list = hthp.get_fault_list(i)
assert isinstance(fault_list,
list), "'fault_list' must be of type list"
assert len(fault_list) == 1
entry = fault_list[0]
assert isinstance(entry, dict), "'entry' must be of type dict"
index = entry["index"]
assert isinstance(index, int), "'index' must be of type int"
assert 0 <= index < hthp.get_fault_list_size()
error = entry["error"]
assert isinstance(error, int), "'error' must be of type int"
assert error >= 0
dt = entry["datetime"]
assert isinstance(
dt, datetime.datetime), "'dt' must be of type datetime"
msg = entry["message"]
assert isinstance(msg, str), "'msg' must be of type str"
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_get_fault_list_with_index_raises_IOError(self, hthp: HtHeatpump):
with pytest.raises(IOError):
hthp.get_fault_list(-1) # index=-1 is invalid
with pytest.raises(IOError):
hthp.get_fault_list(9999) # index=9999 is invalid
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_get_fault_list_with_indices(self, hthp: HtHeatpump):
size = hthp.get_fault_list_size()
for cnt in range(size + 1):
indices = random.sample(range(size), cnt)
fault_list = hthp.get_fault_list(*indices)
assert isinstance(fault_list,
list), "'fault_list' must be of type list"
for entry in fault_list:
assert isinstance(entry, dict), "'entry' must be of type dict"
index = entry["index"]
assert isinstance(index, int), "'index' must be of type int"
assert 0 <= index < hthp.get_fault_list_size()
error = entry["error"]
assert isinstance(error, int), "'error' must be of type int"
assert error >= 0
dt = entry["datetime"]
assert isinstance(
dt, datetime.datetime), "'dt' must be of type datetime"
msg = entry["message"]
assert isinstance(msg, str), "'msg' must be of type str"
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
@pytest.mark.parametrize("name, param", HtParams.items())
def test_get_param(self, hthp: HtHeatpump, name: str, param: HtParam):
value = hthp.get_param(name)
assert value is not None, "'value' must not be None"
assert param.in_limits(value)
#assert 0
def test_get_param_raises_KeyError(self, cmdopt_device: str,
cmdopt_baudrate: int):
hp = HtHeatpump(device=cmdopt_device, baudrate=cmdopt_baudrate)
with pytest.raises(KeyError):
hp.get_param("BlaBlaBla")
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
@pytest.mark.parametrize("name, param", HtParams.items())
def test_set_param(self, hthp: HtHeatpump, name: str, param: HtParam):
pass # TODO
#assert 0
def test_set_param_raises_KeyError(self, cmdopt_device: str,
cmdopt_baudrate: int):
hp = HtHeatpump(device=cmdopt_device, baudrate=cmdopt_baudrate)
with pytest.raises(KeyError):
hp.set_param("BlaBlaBla", 123)
#assert 0
@pytest.mark.parametrize(
"name, param",
[(name, param) for name, param in HtParams.items()
if param.data_type in (HtDataTypes.INT, HtDataTypes.FLOAT)])
def test_set_param_raises_ValueError(self, cmdopt_device: str,
cmdopt_baudrate: int, name: str,
param: HtParam):
hp = HtHeatpump(device=cmdopt_device, baudrate=cmdopt_baudrate)
with pytest.raises(ValueError):
hp.set_param(name, param.min_val - 1,
ignore_limits=False) # type: ignore
with pytest.raises(ValueError):
hp.set_param(name, param.max_val + 1,
ignore_limits=False) # type: ignore
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_in_error(self, hthp: HtHeatpump):
in_error = hthp.in_error
assert isinstance(in_error, bool), "'in_error' must be of type bool"
assert in_error == hthp.get_param("Stoerung")
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_query(self, hthp: HtHeatpump):
values = hthp.query()
# { "HKR Soll_Raum": 21.0,
# "Stoerung": False,
# "Temp. Aussen": 8.8,
# # ...
# }
assert isinstance(values, dict), "'values' must be of type dict"
assert len(values) == len(HtParams)
for n, v in values.items():
assert n in HtParams
assert v is not None
assert HtParams[n].in_limits(v)
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
@pytest.mark.parametrize("names", [
random.sample(HtParams.keys(), cnt)
for cnt in range(len(HtParams) + 1)
])
def test_query_with_names(self, hthp: HtHeatpump, names: List[str]):
values = hthp.query(*names)
# { "HKR Soll_Raum": 21.0,
# "Stoerung": False,
# "Temp. Aussen": 8.8,
# # ...
# }
assert isinstance(values, dict), "'values' must be of type dict"
assert not names or len(values) == len(set(names))
for n, v in values.items():
assert n in HtParams
assert not names or n in names
assert v is not None
assert HtParams[n].in_limits(v)
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_fast_query(self, hthp: HtHeatpump):
values = hthp.fast_query()
assert isinstance(values, dict), "'values' must be of type dict"
assert len(values) == len(HtParams.of_type("MP"))
for n, v in values.items():
assert n in HtParams
assert v is not None
assert HtParams[n].in_limits(v)
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
@pytest.mark.parametrize("names", [
random.sample(HtParams.of_type("MP").keys(), cnt)
for cnt in range(len(HtParams.of_type("MP")) + 1)
])
def test_fast_query_with_names(self, hthp: HtHeatpump, names: List[str]):
values = hthp.fast_query(*names)
assert isinstance(values, dict), "'values' must be of type dict"
assert not names or len(values) == len(set(names))
for n, v in values.items():
assert n in HtParams
assert not names or n in names
assert v is not None
assert HtParams[n].in_limits(v)
#assert 0
def test_fast_query_with_names_raises_KeyError(self, cmdopt_device: str,
cmdopt_baudrate: int):
hp = HtHeatpump(device=cmdopt_device, baudrate=cmdopt_baudrate)
with pytest.raises(KeyError):
hp.fast_query("BlaBlaBla")
#assert 0
@pytest.mark.parametrize("names", [
random.sample(HtParams.of_type("SP").keys(), cnt)
for cnt in range(1,
len(HtParams.of_type("SP")) + 1)
])
def test_fast_query_with_names_raises_ValueError(self, cmdopt_device: str,
cmdopt_baudrate: int,
names: List[str]):
hp = HtHeatpump(device=cmdopt_device, baudrate=cmdopt_baudrate)
with pytest.raises(ValueError):
hp.fast_query(*names)
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_get_time_progs(self, hthp: HtHeatpump):
time_progs = hthp.get_time_progs()
assert isinstance(time_progs,
List), "'time_progs' must be of type list"
assert len(time_progs) > 0
assert all(
[isinstance(time_prog, TimeProgram) for time_prog in time_progs])
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
@pytest.mark.parametrize(
"index",
range(5)) # TODO range(5) -> range(len(hthp.get_time_progs()))
def test_get_time_prog(self, hthp: HtHeatpump, index: int):
time_prog = hthp.get_time_prog(index, with_entries=False)
assert isinstance(
time_prog, TimeProgram), "'time_prog' must be of type TimeProgram"
time_prog = hthp.get_time_prog(index, with_entries=True)
assert isinstance(
time_prog, TimeProgram), "'time_prog' must be of type TimeProgram"
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
@pytest.mark.parametrize("index", [-1, 5])
def test_get_time_prog_raises_IOError(self, hthp: HtHeatpump, index: int):
with pytest.raises(IOError):
hthp.get_time_prog(index, with_entries=False)
with pytest.raises(IOError):
hthp.get_time_prog(index, with_entries=True)
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
@pytest.mark.parametrize(
"index, day, num",
[ # for ALL time program entries
(index, day, num) for index in range(5) for day in range(7)
for num in range(7)
])
def test_get_time_prog_entry(self, hthp: HtHeatpump, index: int, day: int,
num: int):
entry = hthp.get_time_prog_entry(index, day, num)
assert isinstance(
entry, TimeProgEntry), "'entry' must be of type TimeProgEntry"
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
@pytest.mark.parametrize(
"index, day, num",
[
(5, 0, 0), # index=5 is invalid
(0, 7, 0), # day=7 is invalid
(0, 0, 7), # num=7 is invalid
])
def test_get_time_prog_entry_raises_IOError(self, hthp: HtHeatpump,
index: int, day: int,
num: int):
with pytest.raises(IOError):
hthp.get_time_prog_entry(index, day, num)
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_set_time_prog_entry(self, hthp: HtHeatpump):
pass # TODO
#assert 0
@pytest.mark.run_if_connected
@pytest.mark.usefixtures("reconnect")
def test_set_time_prog(self, hthp: HtHeatpump):
pass # TODO
class TestHtParam:
@pytest.mark.parametrize("str, data_type, exp_value", [
("TestString", HtDataTypes.STRING, "TestString"),
("0", HtDataTypes.BOOL, False),
("1", HtDataTypes.BOOL, True),
("True", HtDataTypes.BOOL, True),
("False", HtDataTypes.BOOL, False),
("true", HtDataTypes.BOOL, True),
("false", HtDataTypes.BOOL, False),
("yes", HtDataTypes.BOOL, True),
("no", HtDataTypes.BOOL, False),
("y", HtDataTypes.BOOL, True),
("n", HtDataTypes.BOOL, False),
("TRUE", HtDataTypes.BOOL, True),
("FALSE", HtDataTypes.BOOL, False),
("YES", HtDataTypes.BOOL, True),
("NO", HtDataTypes.BOOL, False),
("Y", HtDataTypes.BOOL, True),
("N", HtDataTypes.BOOL, False),
("123", HtDataTypes.INT, 123),
("-321", HtDataTypes.INT, -321),
("123.456", HtDataTypes.FLOAT, 123.456),
("-321.456", HtDataTypes.FLOAT, -321.456),
("789", HtDataTypes.FLOAT, 789),
# -- should raise a 'ValueError':
("abc", HtDataTypes.BOOL, None),
("def", HtDataTypes.INT, None),
("--99", HtDataTypes.INT, None),
("12+55", HtDataTypes.INT, None),
("ghi", HtDataTypes.FLOAT, None),
("--99.0", HtDataTypes.FLOAT, None),
("12.3+55.9", HtDataTypes.FLOAT, None),
# ...
])
def test_from_str(self, str, data_type, exp_value):
if exp_value is None:
with pytest.raises(ValueError):
HtParam.from_str(str, data_type)
else:
assert HtParam.from_str(str, data_type) == exp_value
#assert 0
@pytest.mark.parametrize("val, data_type, exp_str", [
("TestString", HtDataTypes.STRING, "TestString"),
(False, HtDataTypes.BOOL, "0"),
(True, HtDataTypes.BOOL, "1"),
(123, HtDataTypes.INT, "123"),
(-321, HtDataTypes.INT, "-321"),
(123.456, HtDataTypes.FLOAT, "123.456"),
(-321.456, HtDataTypes.FLOAT, "-321.456"),
(789, HtDataTypes.FLOAT, "789.0"),
(-789, HtDataTypes.FLOAT, "-789.0"),
(789.0, HtDataTypes.FLOAT, "789.0"),
(-789.0, HtDataTypes.FLOAT, "-789.0"),
# ... add some more samples here!
])
def test_to_str(self, val, data_type, exp_str):
assert HtParam.to_str(val, data_type) == exp_str
#assert 0
@pytest.mark.parametrize("name, cmd", [(name, param.cmd()) for name, param in HtParams.items()])
def test_cmd_format(self, name, cmd):
m = re.match("^[S|M]P,NR=(\d+)$", cmd)
assert m is not None, "non valid command string for parameter {!r} [{!r}]".format(name, cmd)