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()