shepherd-core 2023.12.1__py3-none-any.whl → 2024.4.2__py3-none-any.whl

tests/data_models/test_task_models.py

@@ -1,131 +0,0 @@
-from pathlib import Path
-from typing import Union
-
-import pytest
-
-from shepherd_core.data_models import Experiment
-from shepherd_core.data_models import FirmwareDType
-from shepherd_core.data_models import GpioActuation
-from shepherd_core.data_models import GpioEvent
-from shepherd_core.data_models.task import ObserverTasks
-from shepherd_core.data_models.task.emulation import EmulationTask
-from shepherd_core.data_models.task.firmware_mod import FirmwareModTask
-from shepherd_core.data_models.task.harvest import HarvestTask
-from shepherd_core.data_models.task.programming import ProgrammingTask
-from shepherd_core.data_models.testbed import GPIO
-from shepherd_core.data_models.testbed import ProgrammerProtocol
-from shepherd_core.data_models.testbed import Testbed as TasteBad
-
-
-def test_task_model_emu_min() -> None:
-    EmulationTask(
-        input_path="./here",
-    )
-
-
-def test_task_model_emu_fault_in_past() -> None:
-    with pytest.raises(ValueError):
-        EmulationTask(
-            input_path="./here",
-            time_start="1984-01-01 11:12:13",
-        )
-
-
-@pytest.mark.parametrize("value", [0, 1, 2, 3, 4, 4.5, "buffer", "main"])
-def test_task_model_emu_custom_aux(value: Union[float, str]) -> None:
-    EmulationTask(
-        input_path="./here",
-        voltage_aux=value,
-    )
-
-
-@pytest.mark.parametrize("value", [-1.0, 5, "max", "something"])
-def test_task_model_emu_fault_aux(value: Union[float, str]) -> None:
-    with pytest.raises(ValueError):
-        EmulationTask(
-            input_path="./here",
-            voltage_aux=value,
-        )
-
-
-def test_task_model_emu_fault_gpio_actuation() -> None:
-    with pytest.raises(ValueError):
-        EmulationTask(
-            input_path="./here",
-            gpio_actuation=GpioActuation(
-                events=[GpioEvent(delay=5, gpio=GPIO(name="GPIO5"))],
-            ),
-        )
-
-
-def test_task_model_fw_min() -> None:
-    FirmwareModTask(
-        data=Path("/"),
-        data_type=FirmwareDType.path_elf,
-        custom_id=42,
-        firmware_file=Path("fw_to_be.elf"),
-    )
-
-
-def test_task_model_fw_fault_hex() -> None:
-    # just a warning for now
-    FirmwareModTask(
-        data=Path("/"),
-        data_type=FirmwareDType.path_hex,
-        custom_id=42,
-        firmware_file=Path("fw_to_be.hex"),
-    )
-
-
-def test_task_model_hrv_min() -> None:
-    HarvestTask(
-        output_path="./here",
-    )
-
-
-def test_task_model_hrv_duration() -> None:
-    hrv = HarvestTask(
-        output_path="./here",
-        duration=42,
-    )
-    assert hrv.duration.total_seconds() == 42
-
-
-def test_task_model_hrv_too_late() -> None:
-    with pytest.raises(ValueError):
-        HarvestTask(
-            output_path="./here",
-            time_start="1984-01-01 11:12:13",
-        )
-
-
-def test_task_model_observer_min1() -> None:
-    ObserverTasks(
-        observer="peeping tom",
-        owner_id=666,
-        time_prep="2044-01-01 12:13:14",
-        root_path="/usr",
-        abort_on_error=False,
-    )
-
-
-def test_task_model_observer_min2() -> None:
-    path = Path(__file__).with_name("example_config_experiment.yaml")
-    xp = Experiment.from_file(path)
-    ObserverTasks.from_xp(xp=xp, tb=TasteBad(name="shepherd_tud_nes"), tgt_id=1)
-
-
-def test_task_model_prog_min() -> None:
-    ProgrammingTask(
-        firmware_file=Path("fw_to_load.hex"),
-        protocol=ProgrammerProtocol.SWD,
-        mcu_type="nrf52",
-    )
-
-
-def test_task_model_prog_fault_elf() -> None:
-    ProgrammingTask(
-        firmware_file=Path("fw_to_load.elf"),
-        protocol=ProgrammerProtocol.SWD,
-        mcu_type="nrf52",
-    )

tests/data_models/test_testbed_fixtures.py

@@ -1,47 +0,0 @@
-from shepherd_core.data_models.content.firmware import Firmware
-from shepherd_core.data_models.testbed.cape import Cape
-from shepherd_core.data_models.testbed.gpio import GPIO
-from shepherd_core.data_models.testbed.mcu import MCU
-from shepherd_core.data_models.testbed.observer import Observer
-from shepherd_core.data_models.testbed.target import Target
-from shepherd_core.data_models.testbed.testbed import Testbed as TasteBad
-from shepherd_core.testbed_client.fixtures import Fixtures
-
-# ⤷ TasteBad avoids pytest-warning
-
-
-def test_testbed_fixture_cape() -> None:
-    for fix in Fixtures()["Cape"]:
-        Cape(name=fix["name"])
-        Cape(id=fix["id"])
-
-
-def test_testbed_fixture_gpio() -> None:
-    for fix in Fixtures()["GPIO"]:
-        GPIO(name=fix["name"])
-        GPIO(id=fix["id"])
-
-
-def test_testbed_fixture_mcu() -> None:
-    for fix in Fixtures()["MCU"]:
-        MCU(name=fix["name"])
-        mcu = MCU(id=fix["id"])
-        Firmware(name=mcu.fw_name_default)
-
-
-def test_testbed_fixture_observer() -> None:
-    for fix in Fixtures()["Observer"]:
-        Observer(name=fix["name"])
-        Observer(id=fix["id"])
-
-
-def test_testbed_fixture_target() -> None:
-    for fix in Fixtures()["Target"]:
-        Target(name=fix["name"])
-        Target(id=fix["id"])
-
-
-def test_testbed_fixture_tb() -> None:
-    for fix in Fixtures()["Testbed"]:
-        TasteBad(name=fix["name"])
-        TasteBad(id=fix["id"])

tests/data_models/test_testbed_models.py

@@ -1,187 +0,0 @@
-import pytest
-
-from shepherd_core.data_models.testbed import GPIO
-from shepherd_core.data_models.testbed import MCU
-from shepherd_core.data_models.testbed import Cape
-from shepherd_core.data_models.testbed import Direction
-from shepherd_core.data_models.testbed import Observer
-from shepherd_core.data_models.testbed import ProgrammerProtocol
-from shepherd_core.data_models.testbed import Target
-from shepherd_core.data_models.testbed import Testbed as TasteBad
-
-# ⤷ TasteBad avoids pytest-warning
-
-
-def test_testbed_model_cape_min() -> None:
-    cape = Cape(
-        id=9999,
-        name="cappi",
-        version="1.0.0",
-        description="lorem",
-    )
-    print(cape)
-
-
-def test_testbed_model_gpio_min() -> None:
-    gpio = GPIO(
-        id=9999,
-        name="gippi",
-        reg_pru="ABCD",
-        pin_pru="EFGH",
-    )
-    print(gpio)
-
-
-def test_testbed_model_gpio_fault() -> None:
-    with pytest.raises(ValueError):
-        GPIO(
-            id=9999,
-            name="gippi",
-        )
-
-
-def test_testbed_model_gpio_var() -> None:
-    GPIO(
-        id=9999,
-        name="gippi",
-        direction=Direction.Bidirectional,
-        reg_pru="ABCD",
-        pin_pru="EFGH",
-    )
-
-
-def test_testbed_model_mcu_min() -> None:
-    mcu = MCU(
-        id=9922,
-        name="controller2",
-        description="lorem",
-        platform="arm32",
-        core="STM32F7",
-        prog_protocol=ProgrammerProtocol.SWD,
-        fw_name_default="nananana",
-    )
-    print(mcu)
-
-
-def test_testbed_model_observer_min() -> None:
-    obs = Observer(
-        id=9933,
-        name="sheep120",
-        description="not existing",
-        ip="127.0.0.1",
-        mac="FF:FF:FF:FF:FF:FF",
-        room="IIE72",
-        eth_port="375b2",
-        cape=Cape(name="cape53"),
-    )
-    print(obs)
-
-
-def test_testbed_model_observer_fault_cape_a() -> None:
-    with pytest.raises(ValueError):
-        Observer(
-            id=9933,
-            name="sheep120",
-            description="not existing",
-            ip="127.0.0.1",
-            mac="FF:FF:FF:FF:FF:FF",
-            room="IIE72",
-            eth_port="375b2",
-            target_a=Target(id=3),
-        )
-
-
-def test_testbed_model_observer_fault_cape_b() -> None:
-    with pytest.raises(ValueError):
-        Observer(
-            id=9933,
-            name="sheep120",
-            description="not existing",
-            ip="127.0.0.1",
-            mac="FF:FF:FF:FF:FF:FF",
-            room="IIE72",
-            eth_port="375b2",
-            target_b=Target(id=3),
-        )
-
-
-def test_testbed_model_observer_fault_target() -> None:
-    obs = Observer(
-        id=9933,
-        name="sheep120",
-        description="not existing",
-        ip="127.0.0.1",
-        mac="FF:FF:FF:FF:FF:FF",
-        room="IIE72",
-        eth_port="375b2",
-        cape=Cape(name="cape53"),
-        target_a=Target(id=3),
-        target_b=Target(id=2),
-    )
-    obs.get_target(2)
-    obs.get_target(3)
-    obs.get_target_port(2)
-    obs.get_target_port(3)
-    with pytest.raises(ValueError):
-        obs.get_target_port(123456)
-    with pytest.raises(ValueError):
-        obs.get_target(123456)
-
-
-def test_testbed_model_target_min1() -> None:
-    tgt = Target(
-        id=9944,
-        name="TerraTarget",
-        version="v1.00",
-        description="lorem",
-        mcu1=MCU(name="MSP430FR"),
-    )
-    print(tgt)
-
-
-def test_testbed_model_target_min2() -> None:
-    Target(
-        id=9944,
-        name="TerraTarget",
-        version="v1.00",
-        description="lorem",
-        mcu1="MSP430FR",
-        mcu2="MSP430FR",
-    )
-
-
-def test_testbed_model_tb_min() -> None:
-    tb = TasteBad(
-        name="shepherd",
-        id="9955",
-        description="lorem",
-        observers=[Observer(name="sheep02")],
-        data_on_server="/mnt/driveA",
-        data_on_observer="/mnt/driveB",
-    )
-    print(tb)
-
-
-def test_testbed_model_tb_fault_observer() -> None:
-    with pytest.raises(ValueError):
-        TasteBad(
-            name="shepherd",
-            id="9955",
-            description="lorem",
-            observers=[Observer(name="sheep02"), Observer(name="sheep02")],
-            data_on_server="/mnt/driveA",
-            data_on_observer="/mnt/driveB",
-        )
-
-
-def test_testbed_model_tb_fault_shared() -> None:
-    with pytest.raises(ValueError):
-        TasteBad(
-            name="shepherd",
-            id="9955",
-            description="lorem",
-            observers=[Observer(name="sheep02")],
-            data_on_server="/mnt/driveA",
-            data_on_observer="/mnt/driveB",
-            shared_storage=False,
-        )

tests/decoder_waveform/test_decoder.py

@@ -1,34 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from shepherd_core.decoder_waveform import Uart
-
-
-@pytest.fixture
-def example_path() -> Path:
-    return Path(__file__).resolve().parent.parent.parent / "examples"
-
-
-def test_decode_uart(example_path: Path) -> None:
-    uwd = Uart(example_path / "uart_raw2.csv")
-    _ = uwd.get_symbols()
-    _ = uwd.get_lines()
-    _ = uwd.get_text()
-
-
-def test_decode_speedup(example_path: Path) -> None:
-    uwd = Uart(example_path / "uart_raw2.csv")
-    _ = uwd.get_symbols(force_redo=True)
-    _ = uwd.get_lines(force_redo=True)
-    _ = uwd.get_text(force_redo=True)
-
-    # these now have cached the result
-    _ = uwd.get_symbols()
-    _ = uwd.get_lines()
-    _ = uwd.get_text()
-
-
-def test_decode_chained(example_path: Path) -> None:
-    uwd = Uart(example_path / "uart_raw2.csv")
-    _ = uwd.get_text()  # get_symbols() and get_lines() is executed automatically

tests/fw_tools/conftest.py

@@ -1,5 +0,0 @@
-from pathlib import Path
-
-names_elf = ["build_msp.elf", "build_nrf.elf"]
-
-files_elf = [Path(__file__).resolve().with_name(name) for name in names_elf]

tests/fw_tools/test_converter.py

@@ -1,76 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from shepherd_core import fw_tools
-
-from .conftest import files_elf
-
-
-@pytest.fixture()
-def path_hex(tmp_path: Path) -> Path:
-    path_elf = files_elf[0]
-    path_hex = (tmp_path / (path_elf.stem + ".hex")).resolve()
-    return fw_tools.elf_to_hex(path_elf, path_hex)
-
-
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_elf_to_hex(path_elf: Path, tmp_path: Path) -> None:
-    path_hex = (tmp_path / (path_elf.stem + ".hex")).resolve()
-    path_gen = fw_tools.elf_to_hex(path_elf, path_hex)
-    assert path_hex.exists()
-    assert path_hex.as_posix() == path_gen.as_posix()
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_firmware_to_hex_w_elf(path_elf: Path) -> None:
-    path_gen = fw_tools.firmware_to_hex(path_elf)
-    assert path_gen.exists
-    assert path_gen.suffix.lower() == ".hex"
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-def test_firmware_to_hex_w_hex(path_hex: Path) -> None:
-    path_gen = fw_tools.firmware_to_hex(path_hex)
-    assert path_gen.exists
-    assert path_gen.suffix.lower() == ".hex"
-    assert path_gen.as_posix() == path_hex.as_posix()
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-def test_firmware_to_hex_w_fail() -> None:
-    path_some = Path(__file__).parent / "conftest.py"
-    with pytest.raises(ValueError):
-        _ = fw_tools.firmware_to_hex(path_some)
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-def test_hash() -> None:
-    hash_a = fw_tools.file_to_hash(files_elf[0])
-    hash_b = fw_tools.file_to_hash(files_elf[1])
-    hash_c = fw_tools.file_to_hash(files_elf[1])
-    assert hash_a != hash_b
-    assert hash_b == hash_c
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_base64(path_elf: Path, tmp_path: Path) -> None:
-    b64_a = fw_tools.file_to_base64(path_elf)
-    path_b = (tmp_path / path_elf.name).resolve()
-    fw_tools.base64_to_file(b64_a, path_b)
-    b64_b = fw_tools.file_to_base64(path_b)
-    assert b64_a == b64_b
-    hash_a = fw_tools.file_to_hash(path_elf)
-    hash_b = fw_tools.file_to_hash(path_b)
-    assert hash_a == hash_b
-
-
-# extract_firmware() is indirectly tested with Firmware-Class

tests/fw_tools/test_patcher.py

@@ -1,66 +0,0 @@
-import shutil
-from pathlib import Path
-
-import pytest
-
-from shepherd_core import fw_tools
-
-from .conftest import files_elf
-
-
-@pytest.mark.elf
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_sym_finding(path_elf: Path) -> None:
-    assert fw_tools.find_symbol(path_elf, "SHEPHERD_NODE_ID")
-
-
-@pytest.mark.elf
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_sym_reading(path_elf: Path) -> None:
-    assert fw_tools.read_symbol(path_elf, "SHEPHERD_NODE_ID")
-
-
-@pytest.mark.elf
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_sym_mod(path_elf: Path, tmp_path: Path) -> None:
-    value = 0xCAFE
-    sym = "SHEPHERD_NODE_ID"
-    path_new = tmp_path / path_elf.name
-    shutil.copy(path_elf, path_new)
-    path_gen = fw_tools.modify_symbol_value(path_new, sym, value, overwrite=False)
-    assert path_gen.is_file()
-    assert path_gen.as_posix() != path_new.as_posix()
-    value_new = fw_tools.read_symbol(path_gen, sym)
-    assert value == value_new
-    value_old = fw_tools.read_symbol(path_elf, sym)
-    assert value_new != value_old
-
-
-@pytest.mark.elf
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_sym_mod_overwrite(path_elf: Path, tmp_path: Path) -> None:
-    value = 0xCAFE
-    sym = "SHEPHERD_NODE_ID"
-    path_new = tmp_path / path_elf.name
-    shutil.copy(path_elf, path_new)
-    path_gen = fw_tools.modify_symbol_value(
-        path_new, sym, value, overwrite=True
-    )  # TODO: WinOS-trouble
-    assert path_gen.is_file()
-    assert path_gen.as_posix() == path_new.as_posix()
-    value_new = fw_tools.read_symbol(path_gen, sym)
-    assert value == value_new
-    value_old = fw_tools.read_symbol(path_elf, sym)
-    assert value_new != value_old
-
-
-@pytest.mark.elf
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_id_mod(path_elf: Path, tmp_path: Path) -> None:
-    value = 0xCAFE
-    path_new = tmp_path / path_elf.name
-    shutil.copy(path_elf, path_new)
-    path_gen = fw_tools.modify_uid(path_new, value)
-    assert path_gen.as_posix() == path_new.as_posix()
-    value_new = fw_tools.read_symbol(path_gen, "SHEPHERD_NODE_ID")
-    assert value == value_new

tests/fw_tools/test_validation.py

@@ -1,56 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from shepherd_core import fw_tools
-from shepherd_core.data_models import FirmwareDType
-
-from .conftest import files_elf
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_elf_detection(path_elf: Path) -> None:
-    assert fw_tools.is_elf(path_elf)
-    if "nrf" in path_elf.name:
-        assert fw_tools.is_elf_nrf52(path_elf)
-    elif "msp" in path_elf.name:
-        assert fw_tools.is_elf_msp430(path_elf)
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_elf_determination(path_elf: Path) -> None:
-    assert fw_tools.determine_type(path_elf) == FirmwareDType.path_elf
-    if "nrf" in path_elf.name:
-        assert fw_tools.determine_arch(path_elf) == "nrf52"
-    elif "msp" in path_elf.name:
-        assert fw_tools.determine_arch(path_elf) == "msp430"
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_hex_detection(path_elf: Path, tmp_path: Path) -> None:
-    path_hex = (tmp_path / (path_elf.stem + ".hex")).resolve()
-    path_hex = fw_tools.elf_to_hex(path_elf, path_hex)
-    assert fw_tools.is_hex(path_hex)
-    if "nrf" in path_elf.name:
-        assert fw_tools.is_hex_nrf52(path_hex)
-    elif "msp" in path_elf.name:
-        assert fw_tools.is_hex_msp430(path_hex)
-
-
-@pytest.mark.elf
-@pytest.mark.converter
-@pytest.mark.parametrize("path_elf", files_elf)
-def test_hex_determination(path_elf: Path, tmp_path: Path) -> None:
-    path_hex = (tmp_path / (path_elf.stem + ".hex")).resolve()
-    path_hex = fw_tools.elf_to_hex(path_elf, path_hex)
-    assert fw_tools.determine_type(path_hex) == FirmwareDType.path_hex
-    if "nrf" in path_elf.name:
-        assert fw_tools.determine_arch(path_hex) == "nrf52"
-    elif "msp" in path_elf.name:
-        assert fw_tools.determine_arch(path_hex) == "msp430"

tests/inventory/test_inventory.py

@@ -1,20 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from shepherd_core.inventory import Inventory
-from shepherd_core.inventory import InventoryList
-from shepherd_core.inventory import PythonInventory
-from shepherd_core.inventory import SystemInventory
-from shepherd_core.inventory import TargetInventory
-
-
-@pytest.mark.parametrize("inv", [PythonInventory, SystemInventory, TargetInventory, Inventory])
-def test_collect_data(inv: Inventory) -> None:
-    inv.collect()
-
-
-def test_inventorize(tmp_path: Path) -> None:
-    inv = Inventory.collect()
-    inl = InventoryList(elements=[inv])
-    inl.to_csv(tmp_path / "some.csv")

tests/test_cal_hw.py

@@ -1,34 +0,0 @@
-from typing import Callable
-
-import pytest
-
-from shepherd_core.calibration_hw_def import adc_current_to_raw
-from shepherd_core.calibration_hw_def import adc_raw_to_current
-from shepherd_core.calibration_hw_def import adc_raw_to_voltage
-from shepherd_core.calibration_hw_def import adc_voltage_to_raw
-from shepherd_core.calibration_hw_def import dac_raw_to_voltage
-from shepherd_core.calibration_hw_def import dac_voltage_to_raw
-
-
-@pytest.mark.parametrize("fn", [adc_current_to_raw, adc_voltage_to_raw, dac_voltage_to_raw])
-def test_convert_to_raw(fn: Callable) -> None:
-    values = [-1, -1e-6, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1e-0]
-    value_prev = -1
-    for value in values:
-        value_raw = fn(value)
-        assert value_raw >= 0
-        assert value_raw < 2**18
-        assert value_raw >= value_prev
-        value_prev = value_raw
-
-
-@pytest.mark.parametrize("fn", [adc_raw_to_current, adc_raw_to_voltage, dac_raw_to_voltage])
-def test_convert_to_si(fn: Callable) -> None:
-    values = [-100, -1, 0, 1, 2**6, 2**12, 2**18, 2**24]
-    value_prev = -1
-    for value in values:
-        value_si = fn(value)
-        assert value_si >= 0
-        assert value_si <= 6
-        assert value_si >= value_prev
-        value_prev = value_si