def test_minimum_runtime_on_off_time():
Resource.clearResources()
device_manager = DeviceManager(max_power_budget=800, debug=True)
device = DeviceResource("fake_device", 2000)
policy1 = MinimumRuntime(device, 1)
device.set_runtime_policy([policy1])
device.run()
device_manager.process_managed_devices()
assert device.running()
assert policy1.last_time is not None
asyncio.get_event_loop().run_until_complete(asyncio.sleep(2))
device_manager.process_managed_devices()
assert policy1.current_runtime > 1
device.stop()
device_manager.process_managed_devices()
asyncio.get_event_loop().run_until_complete(asyncio.sleep(5))
device_manager.process_managed_devices()
# We stopped at around 2 seconds of runtime.
assert policy1.current_runtime < 5
def test_time_of_use_policy():
Resource.clearResources()
from aizero.time_of_use_resource import Modes
dm = DeviceManager(max_power_budget=800, debug=True)
fake_time_of_use = Resource("TimeOfUse", variables=["mode"])
fake_time_of_use.set_value("mode", Modes.on_peak)
device = DeviceResource("fake_device", 100)
device.set_runtime_policy([TimeOfUsePolicy(Modes.off_peak)])
device.run()
assert device.running()
dm.process_managed_devices()
assert not device.running()
fake_time_of_use.set_value("mode", Modes.off_peak)
dm.process_managed_devices()
assert device.running()
def test_occupancy_policy():
Resource.clearResources()
device_manager = DeviceManager(max_power_budget=800)
occupancy_resource = Resource(
"SomeOccupancyThing", variables=["occupancy"])
occupancy_resource.setValue("occupancy", True)
off_policy = OffIfUnoccupied(occupancy_resource.name)
dev1 = DeviceResource("dev1", power_usage=100,
device_manager=device_manager.name,
runtime_policy=[off_policy])
dev1.run()
device_manager.process_managed_devices()
assert dev1.running(), "Device should be running"
occupancy_resource.setValue("occupancy", False)
assert off_policy.occupancy.value is False
device_manager.process_managed_devices()
assert not dev1.running(), "Device should not be running"
occupancy_resource.setValue("occupancy", True)
device_manager.process_managed_devices()
assert not dev1.running(), "Device should not be running"
def test_subscribe():
Resource.clearResources()
received = False
publisher = Resource("publisher234523453", ["foo"])
publisher.export_mqtt()
subscriber = MqttResource(
"publisher_sub",
"localhost", ["foo"],
variable_mqtt_map={"foo": "publisher234523453/foo"})
received = subscriber.subscribe2("foo")
loop = asyncio.get_event_loop()
loop.run_until_complete(publisher.mqtt_wrapper.wait_until_connected())
publisher.set_value("foo", '12345')
loop.run_until_complete(asyncio.sleep(1))
assert received.value == '12345'
def test_dataframe_has_timestamp_column():
Resource.clearResources()
dow = DayOfWeekResource()
hod = HourOfDayResource()
assert "timestamp" in dow.dataframe.columns
assert "timestamp" in hod.dataframe.columns
def test_topic_converter():
# we need to do this because we will be creating the resources
# again with the same names clear from previous tests...
Resource.clearResources()
import time
broker = "127.0.0.1"
@mqtt_topic_converter("ResourcePublisher/foo")
def convert_int(value):
return int(value)
publisher = MqttWrapper(Resource("ResourcePublisher", ["foo"]),
broker,
retain_msgs=False)
resource = MqttResource("Test2Resource",
broker, ["foo"],
variable_mqtt_map={"foo": "ResourcePublisher/foo"})
loop = asyncio.get_event_loop()
loop.run_until_complete(resource.wait_until_connected())
loop.run_until_complete(publisher.wait_until_connected())
publisher.resource.setValue("foo", 1)
asyncio.get_event_loop().run_until_complete(asyncio.sleep(10))
assert resource.getValue("foo") == 1
def test_mqtt_wrapper():
# we need to do this because we will be creating the resources
# again with the same names. clear from previous tests...
Resource.clearResources()
import time
broker = "127.0.0.1"
resource = MqttResource("Test1Resource", broker, ["Test1Resource2/foo"])
publisher = MqttWrapper(Resource("Test1Resource2", ["foo"]),
broker,
retain_msgs=False)
loop = asyncio.get_event_loop()
loop.run_until_complete(resource.wait_until_connected())
loop.run_until_complete(publisher.wait_until_connected())
publisher.resource.setValue("foo", "bar")
asyncio.get_event_loop().run_until_complete(asyncio.sleep(10))
assert resource.getValue("Test1Resource2/foo") == "bar"
publisher.resource.setValue("foo", "bar2")
asyncio.get_event_loop().run_until_complete(asyncio.sleep(10))
assert resource.getValue("Test1Resource2/foo") == "bar2"
def test_minimum_runtime():
Resource.clearResources()
device_manager = DeviceManager(max_power_budget=800, debug=True)
device = DeviceResource("fake_device", 2000)
policy1 = MinimumRuntime(device, 1)
policy2 = RunIfCanPolicy()
group = PolicyGroup(or_policies=[policy1, policy2])
device.set_runtime_policy([group])
device.run()
device_manager.process_managed_devices()
assert device.running()
assert policy1.last_time is not None
asyncio.get_event_loop().run_until_complete(asyncio.sleep(2))
device_manager.process_managed_devices()
print(device.to_json())
assert policy1.current_runtime > 1
assert not policy1.can_run()
assert not policy2.can_run()
assert not policy1.run_conditions()
assert not policy2.run_conditions()
assert not device.running()
def test_day_of_week():
Resource.clearResources()
dow = DayOfWeekResource()
weekday = get_current_datetime().date().weekday()
assert weekday == dow.getValue("day_of_week")
def test_hour_of_day():
Resource.clearResources()
hod = HourOfDayResource()
hour = get_current_datetime().time().hour + \
round(get_current_datetime().time().minute / 60, 1)
assert hour == hod.getValue("hour_of_day")
assert hour == HourOfDayResource.hour(get_current_datetime())
def test_zero_power_usage_can_run():
Resource.clearResources()
DeviceManager(max_power_budget=800)
device_1 = DeviceResource("Power Hog 3000", 800)
device_1.run()
device_2 = DeviceResource("Power Hog 3001", 0)
assert not device_2.can_run()
def test_battery_generator_policy():
import asyncio
from aizero.device_resource import DeviceManager, DeviceResource
from aizero.device_resource import TimeOfUsePolicy
from aizero.time_of_use_resource import Modes
from aizero.resource import Resource
Resource.clearResources()
fake_time_of_use = Resource("TimeOfUse", variables=["mode"])
fake_time_of_use.set_value("mode", Modes.on_peak)
fake_power_device = DeviceResource("FakeGeneratorPowerControl")
fake_capacity = Resource("BatteryCapacity", ["capacity"])
fake_capacity.set_value("capacity", 100)
device_manager = DeviceManager(power_source="BatteryGenerator")
generator = BatteryGenerator("BatteryGenerator",
power_generation=1000,
power_control_device=fake_power_device.name,
battery_capacity_resource=fake_capacity.name)
generator.set_runtime_policy([TimeOfUsePolicy(Modes.off_peak)])
# give manager a chance to grab the power source
asyncio.get_event_loop().run_until_complete(asyncio.sleep(1))
fake_power_device.stop()
assert not generator.running()
fake_time_of_use.set_value("mode", Modes.off_peak)
device_manager.process_managed_devices()
assert generator.running()
fake_time_of_use.set_value("mode", Modes.on_peak)
device_manager.process_managed_devices()
assert not generator.running()
fake_power_device.run()
assert generator.running()
fake_power_device.stop()
assert not generator.running()
def test_manager_default_power_source():
Resource.clearResources()
ps1 = Resource("SolarPower", ["available_power"])
ps1.set_value("available_power", 0)
dm = DeviceManager()
asyncio.get_event_loop().run_until_complete(asyncio.sleep(1))
assert dm.available_power == 0
ps1.set_value("available_power", 1000)
assert dm.available_power == 1000
def test_ignore_power_usage():
Resource.clearResources()
dm = DeviceManager()
fake_device = DeviceResource("fd1", 100)
fake_device2 = DeviceResource("fd2", 100)
fake_device.run()
fake_device2.run()
asyncio.get_event_loop().run_until_complete(asyncio.sleep(1))
assert dm.running_power == 200
dm.ignore_power_usage(fake_device2)
assert dm.running_power == 100
def test_multiple_rows_in_dataframe():
Resource.clearResources()
dow = DayOfWeekResource()
hod = HourOfDayResource()
dow.set_value("day_of_week", 1)
dow.set_value("day_of_week", 2)
dow.set_value("day_of_week", 3)
dow.set_value("day_of_week", 4)
assert len(dow.dataframe) == 5
hod.set_value("hour_of_day", 1.2)
hod.set_value("hour_of_day", 2.2)
hod.set_value("hour_of_day", 1.5)
hod.set_value("hour_of_day", 13.1)
assert len(hod.dataframe) == 5
def test_manager_multiple_power_sources():
Resource.clearResources()
ps1 = Resource("PowerSource1", ["available_power"])
ps2 = Resource("PowerSource2", ["available_power"])
dm = DeviceManager(power_source=[ps1.name, ps2.name])
asyncio.get_event_loop().run_until_complete(asyncio.sleep(1))
ps1.set_value("available_power", 10)
ps2.set_value("available_power", 5)
assert dm.available_power == 15
ps1.set_value("available_power", 0)
ps2.set_value("available_power", 0)
assert dm.available_power == 0
def test_runifcan():
Resource.clearResources()
device_manager = DeviceManager(max_power_budget=1000)
device1 = DeviceResource("my special device", power_usage=500)
device2 = DeviceResource("my other device", power_usage=500)
device1.run()
device2.run()
assert device1.running()
assert device2.running()
device4 = DeviceResource("automated device",
power_usage=100,
runtime_policy=RunIfCanPolicy())
assert not device4.running()
device1.stop()
assert device4.running()
def test_group_policy():
Resource.clearResources()
device_manager = DeviceManager(max_power_budget=800)
policy1 = RuntimePolicy(conditions=[lambda: True])
policy2 = RuntimePolicy(conditions=[lambda: False])
and_group = PolicyGroup(policies=[policy1, policy2])
or_group = PolicyGroup(policies=[policy1], or_policies=[policy2])
fake_device = DeviceResource("fake-device", 800)
fake_device_or = DeviceResource("fake-device-or", 800)
fake_device.set_runtime_policy([and_group])
fake_device_or.set_runtime_policy([or_group])
fake_device.run()
fake_device_or.run()
device_manager.process_managed_devices()
assert not fake_device.running()
assert fake_device_or.running()
def test_multi_decorator_topic_converter():
import time
import json
Resource.clearResources()
broker = "127.0.0.1"
@mqtt_topic_converter("Test1Resource2/foo")
@mqtt_topic_converter("Test1Resource3/baz")
def convert_int(value):
return int(value)
@mqtt_topic_converter("Test1Resource4/some_json")
def convert_json(value):
return json.loads(value)
# we need to do this because we will be creating the resources
# again with the same names clear from previous tests...
Resource.clearResources()
publisher = MqttWrapper(Resource("Test1Resource2", ["foo"]),
broker,
retain_msgs=False)
publisher2 = MqttWrapper(Resource("Test1Resource3", ["baz"]),
broker,
retain_msgs=False)
publisher3 = MqttWrapper(Resource("Test1Resource4", ["some_json"]),
broker,
retain_msgs=False)
resource = MqttResource("Test1Resource",
broker, ["foo", "baz", "some_json"],
variable_mqtt_map={
"foo": "Test1Resource2/foo",
"baz": "Test1Resource3/baz",
"some_json": "Test1Resource4/some_json"
})
loop = asyncio.get_event_loop()
loop.run_until_complete(publisher.wait_until_connected())
loop.run_until_complete(publisher2.wait_until_connected())
loop.run_until_complete(publisher3.wait_until_connected())
loop.run_until_complete(resource.wait_until_connected())
publisher.resource.setValue("foo", 1)
publisher2.resource.setValue("baz", 1)
publisher3.resource.setValue("some_json", '{"foo" : 1}')
loop.run_until_complete(asyncio.sleep(5))
assert resource.getValue("foo") == 1
assert resource.getValue("baz") == 1
assert resource.getValue("some_json")["foo"] == 1
# Test dict object auto-json conversion:
publisher3.resource.setValue("some_json", {"foo": 2})
loop.run_until_complete(asyncio.sleep(5))
assert resource.getValue("some_json")["foo"] == 2
def test_main():
Resource.clearResources()
# test priority system
device_manager = DeviceManager(max_power_budget=800)
device_low = DeviceResource(
"LowPriority", 200, priority=RuntimePriority.low)
device_none = DeviceResource("NonePriority", 200)
device_med = DeviceResource(
"MediumPriority", 200, priority=RuntimePriority.medium)
device_high = DeviceResource(
"HighPriority", 200, priority=RuntimePriority.high)
device_high_too_much_power = DeviceResource(
"HighPriority2", 400, priority=RuntimePriority.high)
device_low_too_much_power = DeviceResource(
"LowPriority2", 400, priority=RuntimePriority.low)
device_low.run()
device_med.run()
device_none.run()
assert device_low.running
assert device_med.running
assert device_none.running
assert device_manager.running_power == 600
assert device_high.can_run()
power_delta = device_manager.overrun_amount(device_low_too_much_power)
assert power_delta, "power delta {} should be > 0".format(power_delta)
assert not device_low_too_much_power.can_run()
power_delta = device_manager.overrun_amount(device_high_too_much_power)
print(power_delta)
assert power_delta
assert device_manager.is_higher_priority(device_med)
assert device_manager.is_higher_priority(device_high)
assert device_manager.is_higher_priority(device_high_too_much_power)
# There should be a couple devices we can kick
kickables = device_manager.kickable_devices(
device_high_too_much_power, power_delta)
print("kickables: {}".format(kickables))
assert kickables is not None
assert device_none not in device_manager.kickable_devices(
device_high_too_much_power, power_delta)
assert device_low in device_manager.kickable_devices(
device_high_too_much_power, power_delta)
device_high_too_much_power.run()
assert not device_low.running()
assert device_high_too_much_power.running()