Struct RealtimePeer 

pub struct RealtimePeer { /* private fields */ }

A running stand-in peer.

Dropping it cancels the listener and every session it is serving; there is no way to leave one running past the end of a test, which is what keeps a suite’s ports and tasks bounded.

Implementations

impl RealtimePeer

pub fn url(&self) -> &str

The URL a client connects to, without the ?model= the client is expected to add.

pub fn addr(&self) -> SocketAddr

The loopback address the peer is listening on.

pub fn record(&self) -> Record

A snapshot of everything observed so far.

pub async fn observe<F>( &self, what: &str, condition: F, ) -> Result<Record, PeerError>

where F: Fn(&Record) -> bool,

Wait until the record satisfies condition, and return it.

The wait completes on the record changing, never on a clock; what names the observation so a peer that never produces it fails with a sentence rather than with a hang.

pub async fn await_upgrade(&self) -> Result<Record, PeerError>

Wait until at least one upgrade has been answered, either way.

pub async fn await_session_update(&self) -> Result<Record, PeerError>

Wait until the client’s session.update has been read.

pub async fn await_appends(&self, count: usize) -> Result<Record, PeerError>

Wait until count uplink frames have been appended.

pub async fn await_cancel(&self) -> Result<Record, PeerError>

Wait until the client has cancelled a response.

pub async fn send_delta( &self, response: &str, audio: &[u8], ) -> Result<Emission, PeerError>

Send one response.output_audio.delta carrying these bytes, base64 per RFC 4648 §4.

pub async fn speak_tone( &self, response: &str, frames: usize, ) -> Result<usize, PeerError>

Speak frames frames of the tone as one delta each, stopping at the first one the peer suppresses. Returns how many reached the socket.

pub async fn send_audio_done( &self, response: &str, ) -> Result<Emission, PeerError>

Send response.output_audio.done, which is where §4.1’s partial-frame padding happens.

pub async fn send_response_done( &self, response: &str, status: &str, ) -> Result<Emission, PeerError>

Send response.done with this status, ending any cancel-race window (§4.3).

pub async fn send_speech_started(&self) -> Result<Emission, PeerError>

Send input_audio_buffer.speech_started, the barge-in trigger of §4.3.

pub async fn send_error( &self, code: &str, message: &str, ) -> Result<Emission, PeerError>

Send an error event (§5.2), which is either the cancel race or session-fatal.

pub async fn send_unknown( &self, event_type: &str, ) -> Result<Emission, PeerError>

Send an event outside §5.2 — what ORB-12 requires be ignored with a counter.

pub async fn send_malformed( &self, malformed: Malformed, ) -> Result<Emission, PeerError>

Send a frame that cannot be read as an event (§5.3).

pub async fn send_oversize(&self, bytes: usize) -> Result<Emission, PeerError>

Send one text frame of at least bytes bytes — §5.3’s 1 MiB bound is 1 048 576 (ORB-11).

pub async fn close_normally(&self) -> Result<Emission, PeerError>

Close the connection with 1000, the way a well-behaved far end ends a session (ORB-16).

pub async fn reset(&self) -> Result<Emission, PeerError>

Reset the connection: no close frame, no close handshake (ORB-16’s second half).

pub async fn shutdown(self)

Stop serving and join every task the peer owns.

Dropping the peer does the same thing without the join; this exists for a test that wants to prove there is no orphan left behind.

Trait Implementations

impl Debug for RealtimePeer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for RealtimePeer

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.