testprotocols 0.7.2__tar.gz → 0.9.0__tar.gz

{testprotocols-0.7.2/src/testprotocols.egg-info → testprotocols-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testprotocols
-Version: 0.7.2
+Version: 0.9.0
 Summary: Common Test Resource Layer — capability and device protocols for telco testing.
 Author-email: Alottabits <rjvisser@alottabits.com>
 Maintainer-email: Alottabits <rjvisser@alottabits.com>

{testprotocols-0.7.2 → testprotocols-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "testprotocols"
-version = "0.7.2"
+version = "0.9.0"
 description = "Common Test Resource Layer — capability and device protocols for telco testing."
 requires-python = ">=3.12"
 dependencies = []

{testprotocols-0.7.2 → testprotocols-0.9.0}/src/testprotocols/__init__.py

@@ -1,6 +1,6 @@
 """testprotocols — capability and device Protocols for telco resources under test."""
 
-__version__ = "0.7.2"
+__version__ = "0.9.0"
 
 from testprotocols.aftr_gateway import AftrGateway
 from testprotocols.appliance_nat import ApplianceNat
@@ -8,8 +8,10 @@ from testprotocols.appliance_uplinks import ApplianceUplinks
 from testprotocols.appliance_vlans import ApplianceVlans
 from testprotocols.arp_client import ArpClient
 from testprotocols.bgp import Bgp
+from testprotocols.config_ownership import ConfigOwnership
 from testprotocols.conntrack import Conntrack, ConntrackWhiteBox
 from testprotocols.content_filtering import ContentFiltering
+from testprotocols.device_info import DeviceInfo
 from testprotocols.device_lifecycle import DeviceLifecycle
 from testprotocols.device_management import DeviceManagement
 from testprotocols.devices.base import BaseDeviceProtocol
@@ -60,6 +62,7 @@ from testprotocols.mac_table import MacTable
 from testprotocols.multicast_client import MulticastClient
 from testprotocols.nat import Nat
 from testprotocols.netem_controller import NetemController
+from testprotocols.network_attachment import NetworkAttachment
 from testprotocols.nmap_scanner import NmapScanner
 from testprotocols.ntp_client import NtpClient
 from testprotocols.ntp_config import NtpConfig
@@ -67,6 +70,7 @@ from testprotocols.ospf import Ospf
 from testprotocols.packet_filter import PacketFilter, PacketFilterWhiteBox
 from testprotocols.pcap_capture import PcapCapture
 from testprotocols.pdu_controller import PduController
+from testprotocols.placement import PlacementPipe, PlacementPorts
 from testprotocols.port_poe import PortPoe
 from testprotocols.port_security import PortSecurity
 from testprotocols.port_status import PortStatus
@@ -95,6 +99,7 @@ from testprotocols.threat_prevention import ThreatPrevention
 from testprotocols.tr069_client import Tr069Client
 from testprotocols.tr069_server import Tr069Server
 from testprotocols.traffic_shaping import TrafficShaping
+from testprotocols.uplink_ports import UplinkPortRef, UplinkPorts
 from testprotocols.upnp_client import UpnpClient
 from testprotocols.vlan_client import VlanClient
 from testprotocols.wan_link_admin import WanLinkAdmin
@@ -116,10 +121,12 @@ __all__ = [
     "ArpClient",
     "BaseDeviceProtocol",
     "Bgp",
+    "ConfigOwnership",
     "Conntrack",
     "ConntrackWhiteBox",
     "ContentFiltering",
     "CpeDevice",
+    "DeviceInfo",
     "DeviceLifecycle",
     "DeviceManagement",
     "DhcpClient",
@@ -153,6 +160,7 @@ __all__ = [
     "MulticastClient",
     "Nat",
     "NetemController",
+    "NetworkAttachment",
     "NmapScanner",
     "NtpClient",
     "NtpConfig",
@@ -161,6 +169,8 @@ __all__ = [
     "PacketFilterWhiteBox",
     "PcapCapture",
     "PduController",
+    "PlacementPipe",
+    "PlacementPorts",
     "PortPoe",
     "PortSecurity",
     "PortStatus",
@@ -197,6 +207,8 @@ __all__ = [
     "Tr069Server",
     "TrafficControllerDevice",
     "TrafficShaping",
+    "UplinkPortRef",
+    "UplinkPorts",
     "UpnpClient",
     "VlanClient",
     "WanLinkAdmin",

testprotocols-0.9.0/src/testprotocols/config_ownership.py

@@ -0,0 +1,21 @@
+"""Config ownership template.
+
+Defines the abstract contract for session write-ownership of a device's
+network configuration — e.g. a warm-spare member whose primary owns the
+writes. The natural home for future redundancy-role facts.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class ConfigOwnership(Protocol):
+    """Abstract contract for network-config write ownership."""
+
+    @property
+    def manages_network(self) -> bool:
+        """Whether this session owns the device's network configuration.
+        False for a warm-spare member whose primary owns the writes."""
+        ...

testprotocols-0.9.0/src/testprotocols/device_info.py

@@ -0,0 +1,22 @@
+"""Device info template.
+
+Defines the abstract contract for a device's inventory identity — today the
+hardware model. Vendor-neutral metadata the driver resolves from its
+management API, inventory config, or class knowledge; the coverage axis for
+model-parameterised tests. Extensible with further identity facts (serial,
+firmware version) when a consumer needs them.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class DeviceInfo(Protocol):
+    """Abstract contract for device inventory identity."""
+
+    @property
+    def model(self) -> str:
+        """Hardware model identifier (e.g. ``"MX250"``)."""
+        ...

testprotocols-0.9.0/src/testprotocols/devices/__init__.py

@@ -0,0 +1,80 @@
+"""Device archetype registry — maps inventory device_type strings to Protocols."""
+
+from __future__ import annotations
+
+import importlib
+from dataclasses import dataclass
+from typing import Any, cast, get_type_hints
+
+_registry: dict[str, DeviceTypeSpec] = {}
+
+#: The sole sanctioned non-capability members — BaseDeviceProtocol's universal
+#: identity pair (see devices/base.py).
+IDENTITY_MEMBERS = frozenset({"device_name", "device_type"})
+
+
+def non_capability_members(protocol: type) -> frozenset[str]:
+    """Members of *protocol* that are neither capability Protocols nor identity.
+
+    A capability member is annotated with a ``typing.Protocol`` class. Scalar
+    annotations (``str``, ``bool``, ``tuple``…) and property-declared members
+    (which carry no annotation at all) are both offenders. ``__protocol_attrs__``
+    is the CPython 3.12 runtime detail ``typing.get_protocol_members``
+    supersedes in 3.13; one cast keeps that knowledge here.
+    """
+    hints = get_type_hints(protocol)
+    members: frozenset[str] = frozenset(cast("Any", protocol).__protocol_attrs__)
+    return frozenset(
+        member
+        for member in members - IDENTITY_MEMBERS
+        if not getattr(hints.get(member), "_is_protocol", False)
+    )
+
+
+@dataclass(frozen=True)
+class DeviceTypeSpec:
+    """Registration record: inventory string -> @runtime_checkable Protocol class."""
+
+    name: str
+    protocol: type
+
+
+def register_device_type(name: str, protocol: type) -> DeviceTypeSpec:
+    """Register *protocol* as the contract for inventory devices typed *name*.
+
+    Fails closed on archetype drift: every member must be a capability
+    Protocol (the BaseDeviceProtocol identity pair excepted) — see
+    docs/architecture/capability-only-archetypes.md. Returns the spec; also
+    stored in the module-level registry so ``get_device_type(name)`` can look
+    it up by inventory string.
+    """
+    offenders = non_capability_members(protocol)
+    if offenders:
+        raise TypeError(
+            f"device archetype {protocol.__name__!r} ({name!r}) declares "
+            f"non-capability members {sorted(offenders)}; archetypes compose "
+            "capability protocols only — move these into a capability protocol "
+            "(docs/architecture/capability-only-archetypes.md)"
+        )
+    spec = DeviceTypeSpec(name=name, protocol=protocol)
+    _registry[name] = spec
+    return spec
+
+
+def get_device_type(name: str) -> DeviceTypeSpec | None:
+    """Return the spec for inventory *name*, or None if not registered."""
+    return _registry.get(name)
+
+
+def all_device_types() -> dict[str, DeviceTypeSpec]:
+    """Return a copy of the full registry."""
+    return dict(_registry)
+
+
+# Auto-import all archetype modules to trigger registration as a side effect.
+# ``importlib.import_module`` avoids the unused-import / out-of-order-import
+# friction that direct ``from … import …`` statements would create here, and
+# keeps the import section at the top of the file as PEP 8 prefers.
+for _mod in ("client", "cpe", "infra", "sdwan", "switch", "traffic", "voice", "wan"):
+    importlib.import_module(f"testprotocols.devices.{_mod}")
+del _mod

{testprotocols-0.7.2 → testprotocols-0.9.0}/src/testprotocols/devices/base.py

@@ -21,7 +21,9 @@ class BaseDeviceProtocol(Protocol):
     Deliberately scoped to the universal pair — name + type. Anything a
     specific framework wants to expose (vitro's ``config`` /
     ``get_interactive_consoles``, boardfarm's lifecycle hooks, etc.) is
-    the framework's own concern. Frameworks declare a connector Protocol
+    the framework's own concern. Every other archetype member must be a
+    capability Protocol — enforced by ``register_device_type``; see
+    docs/architecture/capability-only-archetypes.md. Frameworks declare a connector Protocol
     on their side that extends this base; testbed plugins compose
     archetype + framework-connector into a combined Protocol where step
     defs need both.

{testprotocols-0.7.2 → testprotocols-0.9.0}/src/testprotocols/devices/client.py

@@ -17,12 +17,14 @@ from testprotocols.ip_routing import IpRouting
 from testprotocols.iperf_client import IperfClient
 from testprotocols.iperf_server import IperfServer
 from testprotocols.multicast_client import MulticastClient
+from testprotocols.network_attachment import NetworkAttachment
 from testprotocols.network_endpoint import NetworkEndpoint
 from testprotocols.network_probe import NetworkProbe
 from testprotocols.nmap_scanner import NmapScanner
 from testprotocols.ntp_client import NtpClient
 from testprotocols.packet_filter import PacketFilter
 from testprotocols.pcap_capture import PcapCapture
+from testprotocols.placement import PlacementPipe
 from testprotocols.qoe_browser import QoeBrowser
 from testprotocols.reachability_responder import ReachabilityResponder
 from testprotocols.syslog_config import SyslogConfig
@@ -128,37 +130,14 @@ class QoeMeasurementClientDevice(QoeClientDevice, Protocol):
     responder: ReachabilityResponder
     pcap: PcapCapture
 
-    test_ip: str
-    """The client's test-plane address as a CIDR (e.g. ``"10.1.30.50/24"``), empty
-    if the client is not homed to a test segment. Vendor-neutral metadata the
-    driver resolves from its homing config — read it here rather than reaching into
-    a framework-specific config object."""
-
-    attachment_segment: str
-    """The declared segment LABEL of a guest-attached client (a client whose
-    test leg sits on a segment the testbed does not manage), empty for managed
-    homing or when undeclared. A stable role name (e.g. ``"provider-vpn"``),
-    never an address: it lets tests resolve "the client on segment X" by
-    declaration when address facts are foreign-owned or discovered late.
-    Vendor-neutral metadata from the driver's attachment config."""
-
-    attachment_subnet: str
-    """The declared subnet (CIDR) of a guest attachment, empty when undeclared.
-    Vendor-neutral metadata from the driver's attachment config — read it here
-    rather than reaching into a framework-specific config object."""
-
-    mgmt_ip: str
-    """The client's management-plane address, empty when undeclared. Published
-    by the driver from its own config so isolation checks never consume a
-    framework-specific config object."""
-
-    pipe_switch: str
-    """Name of the switch carrying this client's dedicated access port (its
-    placement pipe), empty when the client has no declared pipe."""
-
-    pipe_port: str
-    """The dedicated access port whose VLAN is this client's placement knob,
-    empty when the client has no declared pipe."""
+    attachment: NetworkAttachment
+    """Homing metadata — test/mgmt plane addresses and the declared guest
+    attachment (segment label + subnet). See ``NetworkAttachment`` for the
+    boundary against ``NetworkEndpoint``."""
+
+    pipe: PlacementPipe
+    """This client's declared placement pipe (dedicated access port on a
+    managed switch); counterpart of the switch's ``placement`` authorization."""
 
 
 register_device_type("linux_lan_client", LanClientDevice)

{testprotocols-0.7.2 → testprotocols-0.9.0}/src/testprotocols/devices/sdwan.py

@@ -8,8 +8,10 @@ from testprotocols.appliance_nat import ApplianceNat
 from testprotocols.appliance_uplinks import ApplianceUplinks
 from testprotocols.appliance_vlans import ApplianceVlans
 from testprotocols.bgp import Bgp
+from testprotocols.config_ownership import ConfigOwnership
 from testprotocols.conntrack import Conntrack
 from testprotocols.content_filtering import ContentFiltering
+from testprotocols.device_info import DeviceInfo
 from testprotocols.devices import register_device_type
 from testprotocols.devices.base import BaseDeviceProtocol
 from testprotocols.ip_interface import IpInterface
@@ -24,6 +26,7 @@ from testprotocols.static_routes import StaticRoutes
 from testprotocols.syslog_config import SyslogConfig
 from testprotocols.threat_prevention import ThreatPrevention
 from testprotocols.traffic_shaping import TrafficShaping
+from testprotocols.uplink_ports import UplinkPorts
 from testprotocols.wan_link_admin import WanLinkAdmin
 
 
@@ -93,17 +96,20 @@ class SdwanApplianceDevice(BaseDeviceProtocol, Protocol):
     lan: ApplianceVlans
     syslog: SyslogConfig
 
-    model: str
-    """Hardware model identifier (e.g. ``"MX250"``) — vendor-neutral metadata the
-    driver resolves from its management API / inventory. The coverage axis for
-    model-parameterised tests; read it here rather than reaching into a
-    framework-specific config object."""
-
-    manages_network: bool
-    """Whether this session owns the device's network configuration. False for
-    a warm-spare member whose primary owns the writes. Vendor-neutral metadata
-    from the driver's config — read it here rather than reaching into a
-    framework-specific config object."""
+    info: DeviceInfo
+    """Inventory identity (hardware model, e.g. ``"MX250"``) — the coverage
+    axis for model-parameterised tests, resolved by the driver from its
+    management API / inventory."""
+
+    ownership: ConfigOwnership
+    """Whether this session owns the appliance's network configuration —
+    False for a warm-spare member whose primary owns the writes."""
+
+    uplink_ports: UplinkPorts
+    """Declared uplink→switch-port wiring — which managed-switch ports carry
+    each WAN uplink, one entry per pair member (see ``uplink_ports``). A
+    testbed that splices or re-VLANs an uplink resolves the ports here; the
+    switch's ``PlacementPorts`` stays the write authorization."""
 
 
 register_device_type("sdwan_appliance", SdwanApplianceDevice)

{testprotocols-0.7.2 → testprotocols-0.9.0}/src/testprotocols/devices/switch.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 from typing import Protocol, runtime_checkable
 
 from testprotocols.bgp import Bgp
+from testprotocols.device_info import DeviceInfo
 from testprotocols.devices import register_device_type
 from testprotocols.devices.base import BaseDeviceProtocol
 from testprotocols.discovery import Discovery
@@ -22,6 +23,7 @@ from testprotocols.link_aggregation import LinkAggregation
 from testprotocols.mac_table import MacTable
 from testprotocols.ntp_config import NtpConfig
 from testprotocols.ospf import Ospf
+from testprotocols.placement import PlacementPorts
 from testprotocols.port_poe import PortPoe
 from testprotocols.port_security import PortSecurity
 from testprotocols.port_status import PortStatus
@@ -68,11 +70,13 @@ class L2Switch(BaseDeviceProtocol, Protocol):
     syslog: SyslogConfig
     ntp: NtpConfig
 
-    placement_ports: tuple[str, ...]
-    """Designated ports a testbed may re-VLAN to place a client; empty means
-    no placement write is permitted on this switch. Independent of which
-    device's pipe enters a port: pipe ownership is topology, this is write
-    authorization — declared by the switch, the resource's owner."""
+    placement: PlacementPorts
+    """Placement-write authorization — which ports a testbed may re-VLAN to
+    place a client; counterpart of a client's ``pipe`` declaration."""
+
+    info: DeviceInfo
+    """Inventory identity (hardware model) — the coverage axis for
+    model-parameterised switch tests."""
 
 
 register_device_type("managed_switch_l2", L2Switch)

{testprotocols-0.7.2 → testprotocols-0.9.0}/src/testprotocols/devices/voice.py

@@ -21,20 +21,8 @@ class SipPhoneDevice(BaseDeviceProtocol, Protocol):
     Used to drive call-control scenarios (register / invite / cancel / bye) and
     media-plane verification against a SIP server under test.
 
-    A phone has one or more SIP accounts (lines). Most testbeds run single-line
-    phones; multi-line phones expose additional entries in ``aors``.
-
-    ``aors`` is the list of registered SIP URIs in RFC 3261 §6 address-of-record
-    form (``sip:user@host`` with optional ``;params``). ``host`` may be an FQDN,
-    an IPv4 literal (``10.0.0.5``), or an IPv6 bracketed literal
-    (``[2001:db8::5]``) — the driver decides which form matches its testbed's
-    address-resolution context. The list is never empty; ``aors[0]`` is the
-    primary line that single-line operations (``sip_phone.dial``,
-    ``sip_phone.answer``, MWI subscriptions, …) act on.
-
-    ``number`` is the user-part of ``aors[0]`` — the SIP phone's E.164 /
-    dial-string identifier for its primary line. Provided as a convenience so
-    single-line callers don't have to parse SIP URIs.
+    Line identity — ``number`` / ``aors`` — lives on the ``SipPhone``
+    capability protocol.
 
     ``device_name`` / ``device_type`` come from :class:`BaseDeviceProtocol`.
     """
@@ -42,8 +30,6 @@ class SipPhoneDevice(BaseDeviceProtocol, Protocol):
     sip_phone: SipPhone
     ip_interface: IpInterface
     dhcp_client: DhcpClient
-    number: str
-    aors: list[str]
 
 
 @runtime_checkable
@@ -53,16 +39,13 @@ class SipServerDevice(BaseDeviceProtocol, Protocol):
     Provides the server-side SIP surface plus packet capture and file transfer
     for inspecting and exporting signalling exchanges.
 
-    ``aor_domain`` is the host part that callers should embed in SIP AORs
-    targeting this server (``sip:user@<aor_domain>``). May be an FQDN, an
-    IPv4 literal, or an IPv6 bracketed literal — the driver decides which
-    form matches its testbed's address-resolution context.
+    The AOR host part — ``aor_domain`` — lives on the ``SipServer``
+    capability protocol.
     """
 
     sip_server: SipServer
     pcap: PcapCapture
     file_transfer: FileTransfer
-    aor_domain: str
 
 
 register_device_type("linux_sip_phone", SipPhoneDevice)

{testprotocols-0.7.2 → testprotocols-0.9.0}/src/testprotocols/models/sdwan_appliance.py

@@ -555,6 +555,23 @@ class UplinkSelectionRule:
     performance_class: str | None = None
 
 
+@dataclass(frozen=True)
+class UplinkSelectionSettings:
+    """The scalar half of the uplink-selection surface (read-only snapshot).
+
+    The network-wide settings that frame the ordered rule list: which uplink
+    carries default-routed traffic, whether load balancing across uplinks is
+    on, and whether the overlay runs tunnels over all active uplinks
+    concurrently (``active_active_vpn`` — a prerequisite on some products for
+    performance-class steering to evaluate at all). Frozen: a captured
+    snapshot is a restore target, so it must not mutate after capture.
+    """
+
+    default_uplink: str
+    load_balancing_enabled: bool
+    active_active_vpn: bool
+
+
 # --- Static routes ---
 
 

testprotocols-0.9.0/src/testprotocols/network_attachment.py

@@ -0,0 +1,56 @@
+"""Network attachment template.
+
+Defines the abstract contract for an endpoint's *declared or discovered
+homing* onto the testbed's network planes: its test-plane address, its
+management-plane address, and — for a guest-attached endpoint (one whose
+test leg sits on a segment the testbed does not manage) — the declared
+segment label and subnet.
+
+Distinct from ``NetworkEndpoint``: that is the live role-address query
+("give me the WAN address, now"), answered by whatever means the driver
+chooses. ``NetworkAttachment`` is homing *metadata* the driver resolves
+from its own config or discovers at attach time (e.g. a DHCP lease),
+published so consumers never reach into a framework-specific config
+object. Archetypes whose drivers already answer addressing via
+``NetworkEndpoint`` should not also compose this; it earns its place
+where declared homing (segment labels, plane separation) is the
+mechanism under test.
+
+All values are vendor-neutral; empty string means undeclared/not homed.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class NetworkAttachment(Protocol):
+    """Abstract contract for an endpoint's homing metadata."""
+
+    @property
+    def test_ip(self) -> str:
+        """The endpoint's test-plane address as a CIDR (e.g. ``"10.1.30.50/24"``),
+        empty if not homed to a test segment. May be discovered at attach time
+        (e.g. from a DHCP lease) rather than declared."""
+        ...
+
+    @property
+    def mgmt_ip(self) -> str:
+        """The endpoint's management-plane address, empty when undeclared.
+        Published so isolation checks never consume a framework-specific
+        config object."""
+        ...
+
+    @property
+    def segment(self) -> str:
+        """Declared segment LABEL of a guest attachment — a stable role name
+        (e.g. ``"provider-vpn"``), never an address — empty for managed homing
+        or when undeclared. Lets tests resolve "the endpoint on segment X" by
+        declaration when address facts are foreign-owned or discovered late."""
+        ...
+
+    @property
+    def subnet(self) -> str:
+        """Declared subnet (CIDR) of a guest attachment, empty when undeclared."""
+        ...

testprotocols-0.9.0/src/testprotocols/placement.py

@@ -0,0 +1,44 @@
+"""Client-placement templates — both halves of the placement mechanism.
+
+A *placement pipe* is a client's dedicated access port on a managed switch:
+re-VLANing that port is the client's placement knob. The mechanism has two
+sides owned by two devices: the **client** declares which switch/port carries
+its pipe (``PlacementPipe`` — topology fact), and the **switch** declares
+which ports a testbed may re-VLAN at all (``PlacementPorts`` — write
+authorization, owned by the resource's owner). Pipe ownership and write
+authorization are deliberately independent declarations.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class PlacementPipe(Protocol):
+    """Abstract contract for a client's declared placement pipe."""
+
+    @property
+    def switch(self) -> str:
+        """Name of the switch carrying this client's dedicated access port,
+        empty when the client has no declared pipe."""
+        ...
+
+    @property
+    def port(self) -> str:
+        """The dedicated access port whose VLAN is this client's placement
+        knob, empty when the client has no declared pipe."""
+        ...
+
+
+@runtime_checkable
+class PlacementPorts(Protocol):
+    """Abstract contract for a switch's placement-write authorization."""
+
+    @property
+    def ports(self) -> tuple[str, ...]:
+        """Designated ports a testbed may re-VLAN to place a client; empty
+        means no placement write is permitted on this switch. Independent of
+        which device's pipe enters a port: pipe ownership is topology, this is
+        write authorization — declared by the switch, the resource's owner."""
+        ...

{testprotocols-0.7.2 → testprotocols-0.9.0}/src/testprotocols/sdwan_policy_manager.py

@@ -12,16 +12,23 @@ path steering (``set_uplink_selection`` /
 classes reuse ``SLAPolicy`` by name) landed 2026-06-12; the default
 (primary) uplink pair (``get_default_uplink`` / ``set_default_uplink``)
 landed 2026-07-03 — the network-wide "which uplink carries default-routed
-traffic" knob, distinct from per-flow steering. ``apply_policy`` remains
-the generic escape hatch for vendor-shaped policies beyond that surface.
-Application-match steering grows on evidence.
+traffic" knob, distinct from per-flow steering. The SLA read-back
+(``get_sla_policies``), the scalar-settings snapshot
+(``get_uplink_selection_settings``) and the concurrent-overlay-tunnels
+write (``set_active_active_vpn``) landed 2026-08-10 — the read-back and
+converge surface for the settings the rule list rides on. ``apply_policy``
+remains the generic escape hatch for vendor-shaped policies beyond that
+surface. Application-match steering grows on evidence.
 """
 
 from __future__ import annotations
 
 from typing import Any, Protocol, runtime_checkable
 
-from testprotocols.models.sdwan_appliance import UplinkSelectionRule
+from testprotocols.models.sdwan_appliance import (
+    UplinkSelectionRule,
+    UplinkSelectionSettings,
+)
 from testprotocols.models.wan_edge import AppFlow, SLAPolicy
 
 
@@ -86,3 +93,34 @@ class SdwanPolicyManager(Protocol):
     def get_uplink_selection(self) -> list[UplinkSelectionRule]:
         """Return the uplink-selection rules in evaluation order."""
         ...
+
+    def get_sla_policies(self) -> list[SLAPolicy]:
+        """Return the configured SLA policies (performance classes).
+
+        The read-back for ``configure_sla_policy`` / ``remove_sla_policy``:
+        thresholds as the product stores them, names as configured. Policies
+        the product created outside this session are included — a caller
+        arranging classes captures this read as its restore reference and
+        removes only what it configured.
+        """
+        ...
+
+    def get_uplink_selection_settings(self) -> UplinkSelectionSettings:
+        """Return the scalar settings framing the uplink-selection rule list.
+
+        One snapshot of the network-wide knobs — default uplink, load
+        balancing, concurrent overlay tunnels — read together so a caller
+        converging or restoring them works from a single consistent capture.
+        """
+        ...
+
+    def set_active_active_vpn(self, enabled: bool) -> None:
+        """Enable or disable concurrent overlay tunnels over all active uplinks.
+
+        On products where performance-class steering only evaluates with
+        concurrent tunnels enabled, this is the gate a testbed converges
+        before arranging classes. Read-back via
+        ``get_uplink_selection_settings``; the ordered rule list and the
+        default uplink are left untouched.
+        """
+        ...

{testprotocols-0.7.2 → testprotocols-0.9.0}/src/testprotocols/sip_phone.py

@@ -13,6 +13,24 @@ from typing import Protocol, runtime_checkable
 class SipPhone(Protocol):
     """Abstract contract for SIP phone operations."""
 
+    @property
+    def number(self) -> str:
+        """The user-part of ``aors[0]`` — the phone's E.164 / dial-string
+        identifier for its primary line. A convenience so single-line callers
+        don't have to parse SIP URIs."""
+        ...
+
+    @property
+    def aors(self) -> list[str]:
+        """Registered SIP URIs in RFC 3261 §6 address-of-record form
+        (``sip:user@host`` with optional ``;params``). ``host`` may be an FQDN,
+        an IPv4 literal, or an IPv6 bracketed literal — the driver decides
+        which form matches its testbed's address-resolution context. Never
+        empty once configured; ``aors[0]`` is the primary line that single-line
+        operations (``dial``, ``answer``, MWI subscriptions, …) act on.
+        Multi-line phones expose additional entries."""
+        ...
+
     def phone_start(self) -> None:
         """Start the SIP phone software."""
         ...