testoperations 0.1.0__py3-none-any.whl

testoperations/__init__.py

@@ -0,0 +1,3 @@
+"""testoperations — framework-agnostic composition over testprotocols capabilities."""
+
+__version__ = "0.1.0"

testoperations/device_management.py

@@ -0,0 +1,39 @@
+"""Device management operations — reboot polling loop.
+
+Receives a resolved ``device_mgmt`` template instance from the caller.
+The thin wrapper ``get_seconds_uptime`` is deleted — step definitions call
+the template method directly.
+"""
+
+from __future__ import annotations
+
+import time
+
+from testprotocols.device_management import DeviceManagement
+
+
+def wait_for_reboot_completion(
+    device_mgmt: DeviceManagement,
+    timeout: int = 60,
+) -> None:
+    """Block until the device has completed a reboot cycle.
+
+    Polls ``device_mgmt.is_online()`` until it transitions from True -> False
+    -> True (or starts from False).  Raises ``TimeoutError`` if *timeout*
+    seconds elapse before the device comes back online.
+    """
+    deadline = time.monotonic() + timeout
+
+    # Wait for device to go offline first
+    while time.monotonic() < deadline:
+        if not device_mgmt.is_online():
+            break
+        time.sleep(0.5)
+
+    # Wait for device to come back online
+    while time.monotonic() < deadline:
+        if device_mgmt.is_online():
+            return
+        time.sleep(0.5)
+
+    raise TimeoutError(f"Device did not complete reboot within {timeout} seconds")

testoperations/dhcp_client.py

@@ -0,0 +1,34 @@
+"""DHCP client operations — compose dhcp_client + ip_interface templates.
+
+These functions orchestrate DHCP lease renewal by delegating to the
+``dhcp_client`` and ``ip_interface`` template instances provided by the caller.
+"""
+
+from __future__ import annotations
+
+from testprotocols.dhcp_client import DhcpClient
+from testprotocols.ip_interface import IpInterface
+
+
+def dhcp_renew_ipv4(dhcp_client: DhcpClient, ip_interface: IpInterface, iface: str) -> str:
+    """Release and renew the DHCPv4 lease, return the new IPv4 address."""
+    dhcp_client.release_dhcp(iface)
+    dhcp_client.renew_dhcp(iface)
+    return ip_interface.get_interface_ipv4addr(iface)
+
+
+def dhcp_renew_stateful_ipv6(dhcp_client: DhcpClient, ip_interface: IpInterface, iface: str) -> str:
+    """Release and renew the stateful DHCPv6 lease, return the new IPv6 address."""
+    dhcp_client.release_ipv6(iface)
+    dhcp_client.renew_ipv6(iface)
+    return ip_interface.get_interface_ipv6addr(iface)
+
+
+def dhcp_renew_stateless_ipv6(
+    dhcp_client: DhcpClient, ip_interface: IpInterface, iface: str
+) -> str:
+    """Release and renew the stateless (SLAAC/DHCPv6-PD) IPv6 configuration,
+    return the new IPv6 address."""
+    dhcp_client.release_ipv6(iface, stateless=True)
+    dhcp_client.renew_ipv6(iface, stateless=True)
+    return ip_interface.get_interface_ipv6addr(iface)

testoperations/firewall.py

@@ -0,0 +1,25 @@
+"""Firewall operations — multi-step coordination over the ``Firewall`` protocol.
+
+Receives a resolved ``firewall`` template instance from the caller.
+"""
+
+from __future__ import annotations
+
+from testprotocols.firewall import Firewall
+
+
+def reset_to_factory_default(firewall: Firewall) -> None:
+    """Remove every operator-added port mapping currently known to *firewall*.
+
+    Iterates ``list_port_mappings()`` and calls ``remove_port_mapping(name)``
+    for each entry. Used as a "Given the firewall is in its factory-default
+    state" precondition: scenarios that mutate firewall rules register their
+    own per-rule teardown; this operation defensively clears any port-mapping
+    leftover from a previous run.
+
+    PacketFilter chain rules are deliberately left alone — wholesale flush
+    would also remove the baseline OpenWrt allow rules that ship with the
+    factory image.
+    """
+    for mapping in firewall.list_port_mappings():
+        firewall.remove_port_mapping(mapping.name)

testoperations/http_server.py

@@ -0,0 +1,28 @@
+"""HTTP server operations — context manager wrapping start/stop lifecycle.
+
+Receives a resolved ``http_server`` template instance from the caller.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Generator
+from contextlib import contextmanager
+
+from testprotocols.http_server import HttpServer
+
+
+@contextmanager
+def start_http_server(
+    http_server: HttpServer,
+    port: str,
+    ip_version: str = "ipv4",
+) -> Generator[str, None, None]:
+    """Context manager that starts an HTTP service and stops it on exit.
+
+    Yields the handle returned by *start_http_service* (typically a PID string).
+    """
+    handle = http_server.start_http_service(port, ip_version)
+    try:
+        yield handle
+    finally:
+        http_server.stop_http_service(port)

testoperations/iperf_client.py

@@ -0,0 +1,54 @@
+"""iPerf client operations — compose iperf_client + iperf_server templates.
+
+Receives resolved ``iperf_client`` and ``iperf_server`` template instances
+from the caller.  The thin wrapper ``stop_iperf`` is deleted — step
+definitions call the template method directly.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def start_iperf(
+    iperf_client: Any,
+    iperf_server: Any,
+    port: int,
+    time: int = 10,
+    udp: bool = False,
+    ip_version: int = 4,
+) -> dict[str, Any]:
+    """Start an iPerf session: receiver first, then sender.
+
+    Returns a dict containing PIDs and log file paths for both sides:
+    ``sender_pid``, ``sender_log``, ``receiver_pid``, ``receiver_log``.
+
+    *iperf_client* and *iperf_server* are typed ``Any`` because the existing
+    operation calls ``start_sender`` / ``start_receiver``, which are not part
+    of the :class:`IperfClient` / :class:`IperfServer` protocol surfaces
+    (``start_traffic_sender`` / ``start_traffic_receiver`` are). Pre-existing
+    tech debt; logic is not modified here.
+    """
+    receiver_result = iperf_server.start_receiver(port, time=time, udp=udp, ip_version=ip_version)
+    sender_result = iperf_client.start_sender(port, time=time, udp=udp, ip_version=ip_version)
+
+    # Unpack (pid, log_file) tuples if the template returns them; otherwise
+    # store the raw return value under _pid and _log keys.
+    try:
+        receiver_pid, receiver_log = receiver_result
+    except (TypeError, ValueError):
+        receiver_pid = receiver_result
+        receiver_log = None
+
+    try:
+        sender_pid, sender_log = sender_result
+    except (TypeError, ValueError):
+        sender_pid = sender_result
+        sender_log = None
+
+    return {
+        "sender_pid": sender_pid,
+        "sender_log": sender_log,
+        "receiver_pid": receiver_pid,
+        "receiver_log": receiver_log,
+    }

testoperations/iperf_generator.py

@@ -0,0 +1,105 @@
+"""iPerf generator operations — traffic generation presets and multi-generator stop.
+
+Receives resolved ``iperf_generator`` template instances from the caller.
+Thin wrappers (start_traffic, stop_traffic, stop_all_traffic, run_traffic)
+are deleted — step definitions call the template method directly.
+"""
+
+from __future__ import annotations
+
+from testprotocols.iperf_generator import IperfGenerator
+from testprotocols.models.traffic import TrafficResult, TrafficSpec
+
+
+def _assert_distinct_peers(peer_a: IperfGenerator, peer_b: IperfGenerator) -> None:
+    """Reject self-loop peer configurations.
+
+    Bidirectional traffic between peers that resolve to the same host would
+    collide on the iperf3 server pool (both clients target the same server
+    on the same port), producing "server is busy" errors for one side.
+    Callers must supply distinct peers.
+    """
+    if peer_a.server_ip == peer_b.server_ip:
+        raise ValueError(
+            f"peer_a and peer_b both resolve to {peer_a.server_ip!r}. "
+            "Bidirectional traffic between the same host is not supported — "
+            "each peer must be at a distinct address."
+        )
+
+
+def _flow_spec(
+    destination_peer: IperfGenerator,
+    bandwidth_mbps: float,
+    dscp: int,
+    duration_s: int,
+    protocol: str,
+) -> TrafficSpec:
+    """Build a TrafficSpec whose destination is *destination_peer*'s server_ip."""
+    return TrafficSpec(
+        destination=destination_peer.server_ip,
+        bandwidth_mbps=bandwidth_mbps,
+        protocol=protocol,
+        dscp=dscp,
+        duration_s=duration_s,
+    )
+
+
+def saturate_link(
+    peer_a: IperfGenerator,
+    peer_b: IperfGenerator,
+    a_to_b_mbps: float,
+    b_to_a_mbps: float | None = None,
+    dscp: int = 0,
+    duration_s: int = 120,
+    protocol: str = "udp",
+) -> dict[str, str]:
+    """Saturate the network path between two peer generators with bidirectional traffic.
+
+    The caller passes two generator objects; each generator is asked to send
+    to the other peer. Addresses never cross the step-def ↔ operation boundary
+    — each peer resolves its counterparty's destination via the peer's own
+    :attr:`server_ip` template property.
+
+    - ``peer_a.start_traffic`` with destination = ``peer_b.server_ip`` (a→b)
+    - ``peer_b.start_traffic`` with destination = ``peer_a.server_ip`` (b→a)
+
+    Pass ``a_to_b_mbps`` alone for symmetric load (both directions at the same
+    rate). Supply ``b_to_a_mbps`` to model asymmetric loads such as a broadband
+    link with faster downstream than upstream. Works for any testbed topology
+    with two or more generators — the caller picks the pair that bracket the
+    path to saturate.
+
+    :param peer_a: First generator (source of a→b, destination of b→a).
+    :param peer_b: Second generator (source of b→a, destination of a→b).
+    :param a_to_b_mbps: Bandwidth in Mbps for the a→b flow (and for b→a when
+        *b_to_a_mbps* is omitted, giving symmetric load).
+    :param b_to_a_mbps: Bandwidth in Mbps for the b→a flow. Defaults to
+        *a_to_b_mbps* for symmetric load.
+    :param dscp: DSCP code point for both flows (default 0 = best-effort).
+    :param duration_s: Flow duration in seconds (default 120).
+    :param protocol: ``"udp"`` (default) or ``"tcp"``.
+    :return: ``{"a_to_b": <flow_id_on_peer_a>, "b_to_a": <flow_id_on_peer_b>}``.
+    :raises ValueError: if ``peer_a.server_ip == peer_b.server_ip``.
+    """
+    _assert_distinct_peers(peer_a, peer_b)
+    if b_to_a_mbps is None:
+        b_to_a_mbps = a_to_b_mbps
+    a_to_b = peer_a.start_traffic(_flow_spec(peer_b, a_to_b_mbps, dscp, duration_s, protocol))
+    b_to_a = peer_b.start_traffic(_flow_spec(peer_a, b_to_a_mbps, dscp, duration_s, protocol))
+    return {"a_to_b": a_to_b, "b_to_a": b_to_a}
+
+
+def stop_all_generators(
+    generators: list[IperfGenerator],
+) -> list[dict[str, TrafficResult]]:
+    """Stop all traffic flows on each generator in *generators*.
+
+    *generators* is a list of resolved iperf_generator template instances.
+
+    Returns a list of ``stop_all_traffic`` results (each a mapping of
+    flow_id to ``TrafficResult``), one per generator, in the same order.
+    """
+    results: list[dict[str, TrafficResult]] = []
+    for gen in generators:
+        results.append(gen.stop_all_traffic())
+    return results

testoperations/netem_controller.py

@@ -0,0 +1,83 @@
+"""Netem controller operations — preset library and transient event injection.
+
+Receives a resolved ``netem`` template instance from the caller.  Thin
+wrappers (set_impairment_profile, clear, set_interface_profile,
+get_impairment_profile) are deleted — step definitions call the template
+method directly.
+"""
+
+from __future__ import annotations
+
+from testprotocols.models.impairment import ImpairmentProfile
+from testprotocols.netem_controller import NetemController
+
+# ---------------------------------------------------------------------------
+# Built-in impairment presets
+# ---------------------------------------------------------------------------
+
+_PRESETS: dict[str, ImpairmentProfile] = {
+    "clean": ImpairmentProfile(latency_ms=0, jitter_ms=0, loss_percent=0.0),
+    "dsl": ImpairmentProfile(latency_ms=20, jitter_ms=5, loss_percent=0.1, bandwidth_limit_mbps=20),
+    "cable": ImpairmentProfile(
+        latency_ms=10, jitter_ms=2, loss_percent=0.05, bandwidth_limit_mbps=100
+    ),
+    "lte": ImpairmentProfile(
+        latency_ms=50, jitter_ms=10, loss_percent=0.2, bandwidth_limit_mbps=50
+    ),
+    "3g": ImpairmentProfile(latency_ms=100, jitter_ms=20, loss_percent=1.0, bandwidth_limit_mbps=7),
+    "satellite": ImpairmentProfile(
+        latency_ms=600, jitter_ms=50, loss_percent=0.5, bandwidth_limit_mbps=10
+    ),
+    "degraded": ImpairmentProfile(latency_ms=200, jitter_ms=50, loss_percent=5.0),
+    "lossy": ImpairmentProfile(latency_ms=50, jitter_ms=10, loss_percent=10.0),
+}
+
+
+def apply_preset(netem_controller: NetemController, preset_name: str) -> None:
+    """Apply a named impairment preset.
+
+    Built-in presets: ``clean``, ``dsl``, ``cable``, ``lte``, ``3g``,
+    ``satellite``, ``degraded``, ``lossy``.
+
+    Raises ``ValueError`` if *preset_name* is not recognised.
+    """
+    if preset_name not in _PRESETS:
+        raise ValueError(f"unknown preset {preset_name!r}; available: {sorted(_PRESETS)}")
+    netem_controller.set_impairment_profile(_PRESETS[preset_name])
+
+
+def inject_blackout(netem_controller: NetemController, duration_ms: int) -> None:
+    """Inject a complete connectivity blackout of *duration_ms* milliseconds."""
+    netem_controller.inject_transient("blackout", duration_ms)
+
+
+def inject_brownout(
+    netem_controller: NetemController,
+    duration_ms: int,
+    loss_percent: float = 50.0,
+) -> None:
+    """Inject a partial connectivity brownout of *duration_ms* ms.
+
+    *loss_percent* controls how much traffic is dropped during the event.
+    """
+    netem_controller.inject_transient("brownout", duration_ms, loss_percent=loss_percent)
+
+
+def inject_latency_spike(
+    netem_controller: NetemController,
+    duration_ms: int,
+    latency_ms: int = 500,
+) -> None:
+    """Inject a latency spike of *latency_ms* ms lasting *duration_ms* ms."""
+    netem_controller.inject_transient("latency_spike", duration_ms, latency_ms=latency_ms)
+
+
+def inject_packet_storm(
+    netem_controller: NetemController,
+    duration_ms: int,
+    duplicate_percent: float = 100.0,
+) -> None:
+    """Inject a packet storm (heavy duplication) of *duration_ms* ms."""
+    netem_controller.inject_transient(
+        "packet_storm", duration_ms, duplicate_percent=duplicate_percent
+    )

testoperations/network_endpoint.py

@@ -0,0 +1,55 @@
+"""Network endpoint operations — polling helpers over the ``NetworkEndpoint`` protocol.
+
+A ``NetworkEndpoint`` returns the address a peer would use to reach a
+device. Right after disruptive events (reboot, link bounce, netem
+blackout/recovery) the underlying interface may transiently have no
+IPv4 lease, so the endpoint returns an empty string. These operations
+let scenarios coordinate over that recovery without hardcoding
+polling loops in step definitions.
+"""
+
+from __future__ import annotations
+
+import time
+
+from testprotocols.network_endpoint import NetworkEndpoint
+
+
+def wait_for_endpoint_ready(
+    endpoint: NetworkEndpoint,
+    timeout_s: int,
+    poll_s: float = 1.0,
+) -> str:
+    """Poll *endpoint* until ``get_ipv4_addr()`` returns a non-empty string.
+
+    Returns the resolved IPv4 address. Raises ``TimeoutError`` if no
+    address is observed within *timeout_s* seconds. Transient exceptions
+    from the underlying capability (e.g. a console glitch mid-recovery)
+    are caught and retried — only the deadline ends the loop.
+
+    Use this after disruptive events whose precise recovery moment is
+    unobservable: e.g. a CPE reboot drops the LAN DHCP lease, and the
+    client regains connectivity at some point during the CPE's boot.
+    The data-plane probes that follow have to wait for *that* moment,
+    not just for the CPE's management plane to come back up.
+    """
+    deadline = time.monotonic() + timeout_s
+    last_error: Exception | None = None
+    while time.monotonic() < deadline:
+        try:
+            ip = endpoint.get_ipv4_addr()
+        except Exception as exc:  # noqa: BLE001
+            last_error = exc
+            ip = ""
+        if ip:
+            return ip
+        time.sleep(poll_s)
+    if last_error is not None:
+        raise TimeoutError(
+            f"network endpoint did not become ready within {timeout_s}s "
+            f"(last error: {last_error!r})"
+        )
+    raise TimeoutError(
+        f"network endpoint did not become ready within {timeout_s}s "
+        f"(get_ipv4_addr kept returning empty)"
+    )

testoperations/pcap_capture.py

@@ -0,0 +1,54 @@
+"""Packet capture operations — context manager wrapping tcpdump lifecycle.
+
+Receives a resolved ``pcap`` template instance from the caller.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any
+
+from testprotocols.pcap_capture import PcapCapture
+
+
+@contextmanager
+def tcpdump(
+    pcap_capture: Any,
+    fname: str,
+    interface: str,
+    filters: str | None = None,
+) -> Generator[None, None, None]:
+    """Context manager that starts a tcpdump capture and stops it on exit.
+
+    The capture is written to *fname* on the device.  An optional BPF *filters*
+    string is forwarded to the underlying template.
+
+    *pcap_capture* is typed ``Any`` because the existing call shape passes
+    arguments that do not match the :class:`PcapCapture` protocol's
+    ``start_tcpdump`` signature (filters is forwarded as a BPF string while the
+    protocol expects ``dict[str, Any] | None``). Pre-existing tech debt; logic
+    is not modified here.
+    """
+    if filters is not None:
+        pcap_capture.start_tcpdump(fname, interface, filters=filters)
+    else:
+        pcap_capture.start_tcpdump(fname, interface)
+    try:
+        yield
+    finally:
+        pcap_capture.stop_tcpdump(fname)
+
+
+def read_tcpdump(
+    pcap_capture: PcapCapture,
+    fname: str,
+    opts: str = "",
+    rm_pcap: bool = True,
+) -> str:
+    """Read a pcap file *fname* via tshark.
+
+    *opts* is forwarded as additional tshark arguments.  If *rm_pcap* is True
+    the pcap file is removed after reading.
+    """
+    return pcap_capture.tshark_read_pcap(fname, additional_args=opts, rm_pcap=rm_pcap)

testoperations/sdwan.py

@@ -0,0 +1,39 @@
+"""SD-WAN failover scenario operations — cross-domain composites.
+
+Receives resolved ``netem`` and ``router`` template instances from the caller.
+These combine netem impairment injection with router path monitoring to
+measure failover convergence behaviour. Operations are assertion-free —
+callers interpret the returned measurements against scenario-specific
+thresholds.
+"""
+
+from __future__ import annotations
+
+import time
+
+from testprotocols.netem_controller import NetemController
+from testprotocols.router import Router
+
+
+def measure_failover_convergence(
+    netem_controller: NetemController,
+    router: Router,
+    impaired_wan: str,
+    timeout_ms: int = 3000,
+) -> float:
+    """Inject a blackout on *netem_controller* and measure how long it takes for
+    *router* to switch away from *impaired_wan*.
+
+    Returns elapsed milliseconds until the active WAN interface changes.
+    """
+    netem_controller.inject_transient("blackout", timeout_ms)
+
+    start = time.monotonic()
+    while True:
+        active = router.get_active_wan_interface()
+        if active != impaired_wan:
+            break
+        time.sleep(0.05)
+
+    elapsed_ms = (time.monotonic() - start) * 1000.0
+    return elapsed_ms

testoperations/sip_phone.py

@@ -0,0 +1,25 @@
+"""SIP phone operations — multi-step call sequences.
+
+Receives resolved ``sip_phone`` template instances from the caller.
+Thin wrappers (answer, disconnect, hold, etc.) are deleted — step definitions
+call the template method directly.
+"""
+
+from __future__ import annotations
+
+from testprotocols.sip_phone import SipPhone
+
+
+def call_a_phone(caller: SipPhone, callee_number: str) -> None:
+    """Initiate a call from *caller* to *callee_number*.
+
+    Takes the caller off-hook and dials the callee's SIP phone number.
+    """
+    caller.off_hook()
+    caller.dial(callee_number)
+
+
+def shutdown_phone(sip_phone: SipPhone) -> None:
+    """Put on-hook and stop the SIP phone application."""
+    sip_phone.on_hook()
+    sip_phone.phone_kill()

testoperations/tr069_server.py

@@ -0,0 +1,25 @@
+"""TR-069 server (NBI) operations — CPE online probe with try/except logic.
+
+Receives a resolved ``tr069_server`` template instance and a ``cpe_id`` string
+from the caller.  Thin wrappers (GPV, SPV, Reboot) are deleted — step
+definitions call the template method directly.
+"""
+
+from __future__ import annotations
+
+from testprotocols.tr069_server import Tr069Server
+
+
+def is_cpe_online(tr069_server: Tr069Server, cpe_id: str) -> bool:
+    """Probe whether a CPE is online by attempting a GPV call.
+
+    Returns True if the ACS can reach the CPE, False otherwise.
+    """
+    try:
+        tr069_server.GPV(
+            "InternetGatewayDevice.DeviceInfo.UpTime",
+            cpe_id=cpe_id,
+        )
+        return True
+    except Exception:
+        return False

testoperations/wifi_client.py

@@ -0,0 +1,34 @@
+"""WiFi client operations — compose wifi_client + wifi_bss templates.
+
+Receives resolved template instances from the caller. Thin wrappers
+(disconnect, is_connected, list_ssids) are deleted — step definitions call
+the template method directly.
+"""
+
+from __future__ import annotations
+
+from testprotocols.wifi_bss import WifiBss
+from testprotocols.wifi_client import WifiClient
+
+
+def connect_wifi_client(
+    wifi_client: WifiClient,
+    wifi_bss: WifiBss,
+    bss_name: str,
+    password: str | None = None,
+    bssid: str | None = None,
+) -> None:
+    """Connect WiFi client using the SSID retrieved from the AP's BSS config.
+
+    *bss_name* is the logical handle the BSS was registered under via
+    ``WifiBss.create_bss``. The operation reads the broadcast SSID from
+    ``wifi_bss.get_bss_config(bss_name).ssid`` and asks the client to
+    associate to it.
+    """
+    config = wifi_bss.get_bss_config(bss_name)
+    wifi_client.wifi_client_connect(config.ssid, password, bssid=bssid)
+
+
+def scan_ssid(wifi_client: WifiClient, ssid_name: str) -> bool:
+    """Return True if *ssid_name* is visible in the scan results."""
+    return ssid_name in wifi_client.list_wifi_ssids()

testoperations-0.1.0.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: testoperations
+Version: 0.1.0
+Summary: Framework-agnostic, assertion-free composition functions over testprotocols capabilities.
+Author-email: Alottabits <rjvisser@alottabits.com>
+Maintainer-email: Alottabits <rjvisser@alottabits.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/alottabits/testprotocols
+Project-URL: Repository, https://github.com/alottabits/testprotocols
+Project-URL: Issues, https://github.com/alottabits/testprotocols/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: testprotocols>=0.1.0
+Dynamic: license-file
+
+# testoperations
+
+Framework-agnostic, assertion-free composition functions over `testprotocols` capabilities. One module per coherent telco domain; functions return facts and raise on operational failures only — pass/fail decisions are the caller's job.
+
+See the [monorepo README](../../README.md) for the full architecture.

testoperations-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+testoperations/__init__.py,sha256=wWnZznHp6EKD8Bw2vlPh1QcSGXCsvX3OhnEwCs0mqok,112
+testoperations/device_management.py,sha256=k1OLZrMnSpN9qcjLJl0MdSujsJuMr8DWLRX7X7OFu8g,1182
+testoperations/dhcp_client.py,sha256=9d4wNnuYED7zaFrfpcnswdbFFHumB-Dj_lCv874HQOU,1349
+testoperations/firewall.py,sha256=3ranwVxsiQGVCEca6PmKPz1Vk8znpBjtO5-9jSrvk6Y,1000
+testoperations/http_server.py,sha256=nJwyN_ATipnpnE0htTs3JKc9fVuqKPbE0vraLzNvdoM,776
+testoperations/iperf_client.py,sha256=JdN47pBfxHj9pcG4gmmNesOgS6uGuoq_W5h5qX7LUKo,1878
+testoperations/iperf_generator.py,sha256=DyjAr-tp8vs_Ds0UInqQTrFQS7E8eAiNqDMgtigs9xc,4331
+testoperations/netem_controller.py,sha256=Bkr0MfbJP7zPOsmPxWeE-9N3nAabuXfK9YwjToKI1v8,3224
+testoperations/network_endpoint.py,sha256=6FST63iP6KM-5efV1PsMC5I1VUtWVN5UYSJheU1NBrg,2073
+testoperations/pcap_capture.py,sha256=OvFwQkNgM8JrKFhSyqJ7fm25xi8PTUhMNoE9iduKpAI,1658
+testoperations/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testoperations/sdwan.py,sha256=hu2oI4Oq0zGFcM2VHuNTRTpErBxwbb3nMqLyRmyYOhs,1212
+testoperations/sip_phone.py,sha256=S8CLUkZ-IBaLWIkqdki_l6V-VM0jsUjxvX-aPttMNSI,741
+testoperations/tr069_server.py,sha256=mYuBzc4IWB01gxjDtmnfst2R3gchzHwctaGZatswmEc,764
+testoperations/wifi_client.py,sha256=V8zCoO9hDH10TaODgQIASymETFCu4jANZR4YBhWv4vM,1181
+testoperations-0.1.0.dist-info/licenses/LICENSE,sha256=No8aJnn7SvNkXpcvHTMrPDGhtZo-usV9AitDA3bEI2s,11340
+testoperations-0.1.0.dist-info/licenses/NOTICE,sha256=l1ggTluhhtKw7DStHRkOpLGibFJw2CjbJXdd2W0Lbuk,404
+testoperations-0.1.0.dist-info/METADATA,sha256=8WdDtkBEVPkOHCmw6-PoNR171n_iqvEVBPgQ8wYxPL8,1371
+testoperations-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+testoperations-0.1.0.dist-info/top_level.txt,sha256=4hvc-bSXXnAL8e1DcWXct190R4ji4H4uTonGd3HfaRM,15
+testoperations-0.1.0.dist-info/RECORD,,

testoperations-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

testoperations-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Alottabits
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

testoperations-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,11 @@
+testprotocols
+Copyright 2026 Alottabits
+
+This product includes software developed at Alottabits.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use the files in this product except in compliance with
+the License. A copy of the License is distributed with this product in
+the file named "LICENSE", and may also be obtained at:
+
+    http://www.apache.org/licenses/LICENSE-2.0

testoperations-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+testoperations