How can I assert equal BoxBody in actix 4.0

[Overdash]

I was using actix 4.0-beta <=15 and had tests that look like the following

let body = err_http_response().into_body();
let expected_resp = APIError {
            code: StatusCode::BAD_REQUEST.as_u16(),
            message: "Validation check failed".to_string(),
            errors: Some(field_errors)
        };
assert_eq!(body, Body::new(json!(expected_resp).to_string()))

I realised my tests now fail after upgrading to beta >= 16 (currently on 4.0.0-beta.21) and Body has been changed to BoxBody - how would one go about asserting a HttpResponse body is equal to an arbitrary JSON/Struct?

[robjtede]

• https://actix.rs/actix-web/actix_web/body/fn.to_bytes.html
• https://actix.rs/actix-web/actix_web/test/index.html#reading-response-payloads

let result: serde_json::Value = test::read_body_json(res).await;
assert_eq!(result, json!(expected);

[Overdash]

So... in order to do this, I now must make my tests async? There's no sync way to do this anymore?

[Overdash]

Nevermind - I found way to do it sync, but it's extremely unergonomic:
assert_eq!(std::str::from_utf8(&body.try_into_bytes().unwrap()[..]).unwrap(), json!(expected).to_string())

Could have just compared them as bytes, but wanted to keep the string comparison for debugging in case the test were to fail. But I feel this is a step backwards for me. But tests pass now so that's good :)

[robjtede]

assert_eq!(body, Body::new(json!(expected_resp).to_string()))

This comparison ignores the fundamental fact of HTTP that bodies are streams of bytes. The updated way to assert body content is async because you cannot assume for a generic body that it is not streamed.

This is a cleaner solution than comparing Body types.

let result: serde_json::Value = test::read_body_json(res).await;
assert_eq!(result, json!(expected);

As a bonus, you would get debug outputs of JSON instead of strings, assuming you only care about the actual JSON structure and not whitespace differences for example.

[Overdash]

For transparency:
Instead of comparing Bodies we can compare Bytes/Strings:

Byte comp:

assert_eq!(&body.try_into_bytes().unwrap()[..], json!(expected).to_string().as_bytes())

String comp:

assert_eq!(std::str::from_utf8(&body.try_into_bytes().unwrap()[..]).unwrap(), json!(expected).to_string())

It's extremely ugly and unelegant. But it works lol

[andrewsokolov]

Compare serde values:

    async fn compare_json(res: ServiceResponse, obj: impl serde::Serialize) {
        assert_eq!(
            serde_json::from_slice::<serde_json::Value>(&to_bytes(res.into_body()).await.unwrap())
                .unwrap(),
            serde_json::to_value(obj).unwrap()
        )
    }

   let res: ServiceResponse = app.call(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);
    compare_json(res, Config {
        debug: false,
        ..Config::default()
    }).await;