mirror of
https://github.com/MrUnknownDE/OpenIris-ESPIDF.git
synced 2026-04-17 05:23:44 +02:00
257 lines
9.7 KiB
Python
257 lines
9.7 KiB
Python
import time
|
|
from tests.utils import has_command_failed, DetectPortChange
|
|
import pytest
|
|
|
|
## TODO
|
|
# {"ping", CommandType::PING}, - tested
|
|
# {"set_wifi", CommandType::SET_WIFI},
|
|
# {"update_wifi", CommandType::UPDATE_WIFI},
|
|
# {"delete_network", CommandType::DELETE_NETWORK},
|
|
# {"update_ap_wifi", CommandType::UPDATE_AP_WIFI},
|
|
# {"set_mdns", CommandType::SET_MDNS}, - tested
|
|
# {"get_mdns_name", CommandType::GET_MDNS_NAME}, - tested
|
|
# {"update_camera", CommandType::UPDATE_CAMERA},
|
|
# {"get_config", CommandType::GET_CONFIG}, - tested
|
|
# {"reset_config", CommandType::RESET_CONFIG}, -tested
|
|
# {"restart_device", CommandType::RESTART_DEVICE} - tested,
|
|
# {"scan_networks", CommandType::SCAN_NETWORKS}, - tested
|
|
# {"get_wifi_status", CommandType::GET_WIFI_STATUS}, - tested
|
|
# {"switch_mode", CommandType::SWITCH_MODE}, - tested
|
|
# {"get_device_mode", CommandType::GET_DEVICE_MODE}, - tested
|
|
# {"set_led_duty_cycle", CommandType::SET_LED_DUTY_CYCLE}, - tested
|
|
# {"get_led_duty_cycle", CommandType::GET_LED_DUTY_CYCLE}, - tested
|
|
# {"get_serial", CommandType::GET_SERIAL}, - tested
|
|
# {"get_led_current", CommandType::GET_LED_CURRENT}, - tested
|
|
# {"get_who_am_i", CommandType::GET_WHO_AM_I}, - tested
|
|
|
|
|
|
def test_sending_invalid_command(get_openiris_device):
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("some_invalid_command")
|
|
assert has_command_failed(command_result)
|
|
|
|
|
|
def test_sending_invalid_command_with_payload(get_openiris_device):
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("some_invalid_command", {"param": "invalid"})
|
|
assert has_command_failed(command_result)
|
|
|
|
|
|
def test_ping_wired(get_openiris_device):
|
|
device = get_openiris_device()
|
|
|
|
command_result = device.send_command("ping")
|
|
assert not has_command_failed(command_result)
|
|
|
|
|
|
@pytest.mark.has_capability("wired")
|
|
@pytest.mark.has_capability("wireless")
|
|
def test_changing_mode_to_wired(get_openiris_device, ensure_board_in_mode):
|
|
device = get_openiris_device()
|
|
|
|
# let's make sure we're in the wireless mode first, if we're going to try changing it
|
|
device = ensure_board_in_mode("wifi", device)
|
|
command_result = device.send_command("switch_mode", {"mode": "uvc"})
|
|
assert not has_command_failed(command_result)
|
|
|
|
# to avoid any issues, let's restart the board
|
|
with DetectPortChange() as port_selector:
|
|
device.send_command("restart_device")
|
|
time.sleep(3)
|
|
|
|
# and since we've changed the ports
|
|
device = get_openiris_device(port_selector.get_new_port())
|
|
# initial read to flush the logs first
|
|
device.send_command("get_device_mode")
|
|
result = device.send_command("get_device_mode")
|
|
assert not has_command_failed(result)
|
|
|
|
|
|
def test_changing_mode_same_mode(get_openiris_device, ensure_board_in_mode):
|
|
device = get_openiris_device()
|
|
result = device.send_command("get_device_mode")
|
|
current_mode = result["results"][0]["result"]["data"]["mode"].lower()
|
|
command_result = device.send_command("switch_mode", {"mode": current_mode})
|
|
assert not has_command_failed(command_result)
|
|
|
|
result = device.send_command("get_device_mode")
|
|
assert not has_command_failed(result)
|
|
assert result["results"][0]["result"]["data"]["mode"].lower() == current_mode
|
|
|
|
|
|
def test_changing_mode_invalid_mode(get_openiris_device):
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("switch_mode", {"mode": "NOT SUPPORTED"})
|
|
assert has_command_failed(command_result)
|
|
|
|
|
|
def test_setting_mdns_name(get_openiris_device, ensure_board_in_mode):
|
|
def check_mdns_name(name: str):
|
|
command_result = device.send_command("get_mdns_name")
|
|
assert not has_command_failed(command_result)
|
|
assert command_result["results"][0]["result"]["data"]["hostname"] == name
|
|
|
|
device = get_openiris_device()
|
|
device = ensure_board_in_mode("wifi", device)
|
|
first_name = "testname1"
|
|
second_name = "testname2"
|
|
# try setting the test mdns name first, just so we know the commands pass
|
|
command_result = device.send_command("set_mdns", {"hostname": first_name})
|
|
assert not has_command_failed(command_result)
|
|
|
|
check_mdns_name(first_name)
|
|
|
|
command_result = device.send_command("set_mdns", {"hostname": second_name})
|
|
assert not has_command_failed(command_result)
|
|
|
|
device.send_command("restart_device")
|
|
# let the board boot, wait till it connects
|
|
time.sleep(3)
|
|
check_mdns_name(second_name)
|
|
|
|
|
|
@pytest.mark.parametrize("payload", [{"name": "awd"}, {}])
|
|
def test_setting_mdns_name_invalid_payload(get_openiris_device, payload):
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("set_mdns", payload)
|
|
assert has_command_failed(command_result)
|
|
|
|
|
|
@pytest.mark.has_capability("wired")
|
|
@pytest.mark.has_capability("wireless")
|
|
def test_reboot_command(get_openiris_device, ensure_board_in_mode):
|
|
device = ensure_board_in_mode("wifi", get_openiris_device())
|
|
|
|
command_result = device.send_command("switch_mode", {"mode": "uvc"})
|
|
assert not has_command_failed(command_result)
|
|
|
|
# we're testing if rebooting actually triggers reboot
|
|
# so to be 100% sure of that, we're changing the mode to UVC and looking for new port
|
|
# which might be a little overkill kill and won't work on boards not supporting both modes
|
|
with DetectPortChange() as port_selector:
|
|
device.send_command("restart_device")
|
|
time.sleep(3)
|
|
|
|
assert len(port_selector.get_new_port())
|
|
|
|
|
|
def test_get_serial(get_openiris_device):
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("get_serial")
|
|
assert not has_command_failed(command_result)
|
|
# test for response integrity as well to uphold the contract
|
|
assert "mac" in command_result["results"][0]["result"]["data"]
|
|
assert "serial" in command_result["results"][0]["result"]["data"]
|
|
|
|
|
|
def test_get_who_am_i(get_openiris_device):
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("get_who_am_i")
|
|
assert not has_command_failed(command_result)
|
|
# test for response integrity as well to uphold the contract
|
|
assert "version" in command_result["results"][0]["result"]["data"]
|
|
assert "who_am_i" in command_result["results"][0]["result"]["data"]
|
|
|
|
|
|
@pytest.mark.has_capability("measure_current")
|
|
def test_get_led_current_supported(get_openiris_device):
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("get_led_current")
|
|
assert not has_command_failed(command_result)
|
|
assert "led_current_ma" in command_result["results"][0]["result"]["data"]
|
|
|
|
|
|
@pytest.mark.lacks_capability("measure_current")
|
|
def test_get_led_current_unsupported(get_openiris_device):
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("get_led_current")
|
|
assert has_command_failed(command_result)
|
|
|
|
|
|
def test_get_led_duty_cycle(get_openiris_device):
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("get_led_duty_cycle")
|
|
assert not has_command_failed(command_result)
|
|
assert (
|
|
"led_external_pwm_duty_cycle" in command_result["results"][0]["result"]["data"]
|
|
)
|
|
|
|
|
|
def test_set_led_duty_cycle(get_openiris_device):
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("set_led_duty_cycle", {"dutyCycle": 0})
|
|
assert not has_command_failed(command_result)
|
|
|
|
command_result = device.send_command("get_led_duty_cycle")
|
|
assert not has_command_failed(command_result)
|
|
assert (
|
|
command_result["results"][0]["result"]["data"]["led_external_pwm_duty_cycle"]
|
|
== 0
|
|
)
|
|
|
|
command_result = device.send_command("set_led_duty_cycle", {"dutyCycle": 100})
|
|
assert not has_command_failed(command_result)
|
|
|
|
command_result = device.send_command("get_led_duty_cycle")
|
|
assert not has_command_failed(command_result)
|
|
assert (
|
|
command_result["results"][0]["result"]["data"]["led_external_pwm_duty_cycle"]
|
|
== 100
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"payload",
|
|
[
|
|
{},
|
|
{"dutyCycle": -1},
|
|
{"dutyCycle": 1.5},
|
|
{"dutyCycle": 150},
|
|
{"awd": 21},
|
|
{"dutyCycle": "21"},
|
|
],
|
|
)
|
|
def test_set_led_duty_cycle_invalid_payload(get_openiris_device, payload):
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("set_led_duty_cycle", payload)
|
|
assert has_command_failed(command_result)
|
|
|
|
|
|
@pytest.mark.has_capability("wireless")
|
|
def test_check_wifi_status(get_openiris_device, ensure_board_in_mode):
|
|
device = ensure_board_in_mode("wifi", get_openiris_device())
|
|
command_result = device.send_command("get_wifi_status")
|
|
assert not has_command_failed(command_result)
|
|
|
|
|
|
@pytest.mark.has_capability("wireless")
|
|
def test_scan_networks(get_openiris_device, ensure_board_in_mode):
|
|
device = ensure_board_in_mode("wifi", get_openiris_device())
|
|
command_result = device.send_command("scan_networks")
|
|
assert not has_command_failed(command_result)
|
|
assert len(command_result["results"][0]["result"]["data"]["networks"]) != 0
|
|
|
|
|
|
def test_get_config(get_openiris_device):
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("get_config")
|
|
assert not has_command_failed(command_result)
|
|
|
|
|
|
def test_reset_config(get_openiris_device):
|
|
# to test the config, we can do two things. Set the mdns, get the config, reset it, get it again and compare
|
|
device = get_openiris_device()
|
|
command_result = device.send_command("set_mdns", {"hostname": "somedifferentname"})
|
|
assert not has_command_failed(command_result)
|
|
|
|
current_config = device.send_command("get_config")
|
|
assert not has_command_failed(current_config)
|
|
|
|
reset_command = device.send_command("reset_config")
|
|
assert not has_command_failed(reset_command)
|
|
|
|
new_config = device.send_command("get_config")
|
|
assert not has_command_failed(new_config)
|
|
|
|
assert not new_config == current_config
|