Struct JsonExact

pub struct JsonExact { /* private fields */ }

Matches on exact JSON data. This will be most useful when the exact contents of a message are important for matching, and any failure to match should cause an error.

Example

use serde_json::json;
use ws_mock::matchers::{JsonExact, Matcher};

let matching_data = r#"{ "data": 42 }"#;
let non_matching_data = r#"{ "data": 0 }"#;

let expected = json!({"data": 42});

let matcher = JsonExact::new(expected);

assert!(matcher.matches(matching_data));
assert!(!matcher.matches(non_matching_data));

Implementations

impl JsonExact

pub fn new(json: Value) -> Self

Examples found in repository

examples/json_match.rs (line 18)

pub async fn main() {
    let expected_json = json!({"message": "heartbeat"});
    let json_msg = serde_json::to_string(&expected_json).expect("Failed to serialize message");

    let server = WsMockServer::start().await;

    WsMock::new()
        .matcher(JsonExact::new(expected_json))
        .respond_with(Message::Text("heartbeat".to_string()))
        .expect(1)
        .mount(&server)
        .await;

    let (stream, _resp) = connect_async(server.uri().await)
        .await
        .expect("Connecting failed");

    let (mut send, mut recv) = stream.split();

    send.send(Message::from(json_msg)).await.unwrap();

    let mut received = Vec::new();

    while let Ok(Some(Ok(message))) = timeout(Duration::from_millis(100), recv.next()).await {
        received.push(message.to_string());
    }

    server.verify().await;
    assert_eq!(vec!["heartbeat"], received);

    server.verify().await;
}

Trait Implementations

impl Debug for JsonExact

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

Formats the value using the given formatter.

impl Matcher for JsonExact

fn matches(&self, text: &str) -> bool