OpenHTF vs pytest pour les tests matériels

import openhtf as htf
from openhtf.plugs import BasePlug
from openhtf.util import units
from tofupilot.openhtf import TofuPilot


class DutPlug(BasePlug):
    """Gère le cycle de vie de la connexion au DUT."""

    def setUp(self):
        self.connected = True  # Remplacer par une vraie connexion

    def read_voltage(self) -> float:
        return 3.31  # Remplacer par une lecture instrument

    def query_firmware(self) -> str:
        return "2.1.0"  # Remplacer par une requête au DUT

    def tearDown(self):
        self.connected = False


@htf.measures(
    htf.Measurement("rail_3v3")
    .in_range(3.2, 3.4)
    .with_units(units.VOLT)
    .doc("Tension du rail d'alimentation 3,3 V"),
)
@htf.PhaseOptions(timeout_s=10)
@htf.plug(dut=DutPlug)
def test_power(test, dut):
    test.measurements.rail_3v3 = dut.read_voltage()


@htf.measures(
    htf.Measurement("firmware_version")
    .equals("2.1.0")
    .doc("Chaîne de version firmware attendue"),
)
@htf.PhaseOptions(timeout_s=5)
@htf.plug(dut=DutPlug)
def test_firmware(test, dut):
    test.measurements.firmware_version = dut.query_firmware()


def main():
    test = htf.Test(
        test_power,
        test_firmware,
        procedure_id="FCT-001",
        part_number="PCBA-100",
    )
    with TofuPilot(test):
        test.execute(test_start=lambda: input("Scanner le numéro de série : "))


if __name__ == "__main__":
    main()

import pytest
from tofupilot import TofuPilotClient


@pytest.fixture(scope="session")
def tofupilot():
    """Initialiser le client TofuPilot pour la session de test."""
    return TofuPilotClient()


@pytest.fixture(scope="session")
def serial_number():
    """Demander le numéro de série à l'opérateur avant l'exécution des tests."""
    return input("Scanner le numéro de série : ")


@pytest.fixture
def dut():
    """Gérer la connexion au DUT. Équivalent d'un Plug OpenHTF."""
    # Setup
    connection = {"connected": True}  # Remplacer par une vraie connexion
    yield connection
    # Teardown
    connection["connected"] = False


def read_voltage() -> float:
    """Lire la tension depuis l'instrument."""
    return 3.31  # Remplacer par une vraie lecture


def query_firmware() -> str:
    """Interroger la version firmware du DUT."""
    return "2.1.0"  # Remplacer par une vraie requête


def test_power_rail(dut):
    """Vérifier que le rail d'alimentation 3,3 V est dans les spécifications."""
    voltage = read_voltage()
    assert 3.2 <= voltage <= 3.4, f"Rail 3,3 V hors plage : {voltage} V"


def test_firmware_version(dut):
    """Vérifier que la version firmware correspond à celle attendue."""
    version = query_firmware()
    assert version == "2.1.0", f"Firmware inattendu : {version}"

from tofupilot.openhtf import TofuPilot

# Encapsuler l'exécution de votre test
with TofuPilot(test):
    test.execute(test_start=lambda: input("Numéro de série : "))
# Mesures, limites, unités, phases, pièces jointes
# sont tous enregistrés automatiquement.

from tofupilot import TofuPilotClient

client = TofuPilotClient()

# Après avoir collecté les résultats, créer une exécution
client.create_run(
    procedure_id="FCT-001",
    unit_under_test={"serial_number": "SN-001", "part_number": "PCBA-100"},
    run_passed=True,
    steps=[
        {
            "name": "test_power_rail",
            "step_passed": True,
            "measurements": [
                {
                    "name": "rail_3v3",
                    "value": 3.31,
                    "unit": "V",
                    "lower_limit": 3.2,
                    "upper_limit": 3.4,
                },
            ],
        },
    ],
)