def test_img_size(self):
# start with 200k
_b1 = b'0x00' * 200 * 1024
_b2 = b'0xFF' * 200 * 1024
with OpenhabTmpItem(None, 'Image') as item, ItemWaiter(OpenhabItem.get_item(item.name)) as item_waiter, \
EventWaiter(item.name, ItemStateChangedEvent) as event_waiter:
k = 383
_b1 = b'\xFF\xD8\xFF' + b'\x00' * (1024 - 3) + b'\x00' * (k - 1) * 1024
_b2 = b'\xFF\xD8\xFF' + b'\xFF' * (1024 - 3) + b'\x00' * (k - 1) * 1024
item.oh_post_update(_b1)
event_waiter.wait_for_event(_b1)
item_waiter.wait_for_state(_b1)
item.oh_post_update(_b2)
event_waiter.wait_for_event(_b2)
item_waiter.wait_for_state(_b2)
assert event_waiter.last_event.value == _b2
assert event_waiter.last_event.old_value == _b1
log.info(f'Image with {len(_b2) / 1024 :.0f}k ok!')
test_ok = item_waiter.states_ok and event_waiter.events_ok
return test_ok
def test_func(self, item_type, test_params):
# create a nice name for the tmp item
item_type = str(item_type).split('.')[-1][:-6]
item_name = f'{item_type}_item_test'
with OpenhabTmpItem(item_type, item_name) as item, ItemWaiter(OpenhabItem.get_item(item_name)) as waiter:
for test_param in test_params:
assert isinstance(test_param, TestParam)
func = getattr(item, test_param.func_name)
if test_param.func_params is None:
func()
else:
if isinstance(test_param.func_params, (str, float, int, bytes)):
func(test_param.func_params)
else:
func(*test_param.func_params)
if waiter.wait_for_state(test_param.result):
log.info(f'{item_type}.{test_param.func_name}() is ok!')
# test properties
if test_param.func_name not in ('percent', 'oh_post_update', 'oh_send_command'):
prop_name = f'is_{test_param.func_name}'
assert getattr(item, prop_name)() is True
log.info(f'{item_type}.{prop_name}() is ok!')
# reset state so we don't get false positives
item.set_value(None)
def test_quantity_type_events(self, dimension):
unit_of_dimension = {
'Length': 'm',
'Temperature': '°C',
'Pressure': 'hPa',
'Speed': 'km/h',
'Intensity': 'W/m²',
'Angle': '°',
'Dimensionless': '',
}
item_name = f'{dimension}_event_test'
with OpenhabTmpItem(item_name, f'Number:{dimension}') as item, \
EventWaiter(item_name, ValueUpdateEvent) as event_watier, \
ItemWaiter(item) as item_waiter:
for state in get_openhab_test_states('Number'):
self.openhab.post_update(
item_name, f'{state} {unit_of_dimension[dimension]}')
event_watier.wait_for_event(state)
item_waiter.wait_for_state(state)
all_events_ok = event_watier.events_ok
return all_events_ok
def test_sw_mode_inverted(self):
mm = MultiModeItem.get_create_item(get_random_name())
with OpenhabTmpItem(None, 'Switch') as switch, ItemWaiter(
OpenhabItem.get_item(switch.name)) as waiter:
switch.on()
waiter.wait_for_state('ON')
mode = SwitchItemValueMode('test',
switch,
invert_switch=True,
logger=log)
mm.add_mode(0, mode)
assert mode.enabled is False, mode.enabled
mode.set_value('asdf')
assert mode.enabled is False, mode.enabled
mode.set_value(0)
assert mode.enabled is False, mode.enabled
switch.off()
waiter.wait_for_state('OFF')
assert mode.enabled is True, mode.enabled
HABApp.core.Items.pop_item(mm.name)
def test_mqtt_state(self):
my_item = MqttItem.get_create_item('test/item_topic')
with ItemWaiter(my_item) as waiter:
for data in self.mqtt_test_data:
my_item.publish(data)
waiter.wait_for_state(data)
return waiter.states_ok
def test_async_oder(self):
with OpenhabTmpItem(
'String',
'AsyncOrderTest') as item, ItemWaiter(item) as waiter:
for _ in range(10):
for i in range(0, 5):
item.oh_post_update(i)
waiter.wait_for_state('4')
def test_func(self, item_type, func_name, test_vals):
with OpenhabTmpItem(item_type) as tmpitem, ItemWaiter(OpenhabItem.get_item(tmpitem.name)) as waiter:
for val in test_vals:
getattr(tmpitem, func_name)(val)
waiter.wait_for_state(val)
for val in test_vals:
tmpitem.set_value(val)
getattr(tmpitem, func_name)()
waiter.wait_for_state(val)
def test_post_update(self, oh_type, values):
if isinstance(values, str):
values = [values]
with OpenhabTmpItem(oh_type) as item, ItemWaiter(item) as waiter:
for value in values:
self.openhab.post_update(item, value)
waiter.wait_for_state(value)
for value in values:
if oh_type != 'Contact':
self.openhab.send_command(item, value)
waiter.wait_for_state(value)
def test_mqtt_pair_item(self):
topic_read = 'test/topic_read'
topic_write = 'test/topic_write'
item = MqttPairItem.get_create_item(topic_read, topic_write)
# Ensure we send on the write topic
with EventWaiter(topic_write, ValueUpdateEvent) as event_waiter:
item.publish('ddddddd')
event_waiter.wait_for_event(value='ddddddd')
# Read Topic has to be updated properly
with ItemWaiter(item) as item_waiter:
self.mqtt.publish(topic_read, 'asdfasdf')
item_waiter.wait_for_state(item)
def test_group_update(self):
item1 = SwitchItem.get_item(self.item1.name)
item2 = SwitchItem.get_item(self.item2.name)
group = GroupItem.get_item(self.group.name)
with ItemWaiter(group) as waiter:
waiter.wait_for_state(None)
item1.oh_post_update('ON')
waiter.wait_for_state('ON')
item1.oh_post_update('OFF')
waiter.wait_for_state('OFF')
item2.oh_post_update('ON')
waiter.wait_for_state('ON')
def test_img_size(self):
# start with 200k
_b1 = b'0x00' * 200 * 1024
_b2 = b'0xFF' * 200 * 1024
with OpenhabTmpItem('Image') as item, ItemWaiter(OpenhabItem.get_item(item.name)) as item_waiter, \
EventWaiter(item.name, ItemStateChangedEvent) as event_waiter:
k = 383
_b1 = b'\xFF\xD8\xFF' + b'\x00' * (1024 - 3) + b'\x00' * (k -
1) * 1024
_b2 = b'\xFF\xD8\xFF' + b'\xFF' * (1024 - 3) + b'\x00' * (k -
1) * 1024
item.oh_post_update(_b1)
event_waiter.wait_for_event(value=_b1)
item_waiter.wait_for_state(_b1)
item.oh_post_update(_b2)
event_waiter.wait_for_event(value=_b2, old_value=_b1)
item_waiter.wait_for_state(_b2)
log.info(f'Image with {len(_b2) / 1024 :.0f}k ok!')
