https://github.com/beltram/asserhttp

Fluent http assertions
https://github.com/beltram/asserhttp

Last synced: 11 days ago
JSON representation

Fluent http assertions

• Host: GitHub
• URL: https://github.com/beltram/asserhttp
• Owner: beltram
• License: apache-2.0
• Created: 2021-06-01T15:34:29.000Z (over 3 years ago)
• Default Branch: main
• Last Pushed: 2024-04-18T12:15:48.000Z (7 months ago)
• Last Synced: 2024-09-19T08:47:47.146Z (about 2 months ago)
• Language: Rust
• Size: 511 KB
• Stars: 36
• Watchers: 3
• Forks: 3
• Open Issues: 7
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
asserhttp



 

   Fluent http response assertions

 








  

  

    

  

  

  

    

  

  

  

    

  

  

  

    

  

  

  

    

  

  

  

    

  






A standard trait for doing fluent assertions over many http client response. Currently, supports

[actix-web](https://actix.rs/docs/testing/), [rocket](https://github.com/SergioBenitez/Rocket),

[reqwest](https://github.com/seanmonstar/reqwest), [hyper](https://github.com/hyperium/hyper),

[axum](https://github.com/tokio-rs/axum), [awc](https://docs.rs/awc) (Actix Web Client),

[surf](https://github.com/http-rs/surf), [ureq](https://github.com/algesten/ureq)

and [isahc](https://github.com/sagebind/isahc).

## Getting started

Add it to your `Cargo.toml`

```toml

asserhttp = { version = "0.6.1", features = ["reqwest"] }

#                             or features = ["hyper"]

#                             or features = ["actix"]

#                             or features = ["axum"]

#                             or features = ["actix-web-client"]

#                             or features = ["rocket"]

#                             or features = ["surf"]

#                             or features = ["ureq"]

#                             or features = ["isahc"]

```

Then use it in your tests, for example on [actix-web](https://actix.rs/docs/testing/),

```rust

use actix_web::{App, HttpResponse, test::{call_service, init_service, TestRequest}, web};

use asserhttp::*;

#[actix_web::test]

async fn sample_test() {

    let app = App::new().route("/", web::get().to(|| async { HttpResponse::Ok().body(json!({"a": "b"})) }));

    call_service(&mut init_service(app).await, TestRequest::get().to_request()).await

        .expect_status_ok()

        .expect_content_type_json()

        .expect_body_json_eq(json!({"a": "b"}));

}

```

or on [reqwest](https://github.com/seanmonstar/reqwest)

```rust

use reqwest;

use asserhttp::*;

#[tokio::test]

async fn my_test() {

    reqwest::get("http://localhost").await

        .expect_status_ok()

        .expect_content_type_json()

        .expect_body_json_eq(json!({"name": "jdoe"}));

}

```

## Customize

You don't like the asserhttp methods name ? That's fine, you can define yours. Define you own trait and use asserhttp 

methods to define your own ! 

As simple as this:

```rust

asserhttp::asserhttp_customize!(MyHttpDsl);

pub trait MyHttpDsl: asserhttp::Asserhttp {

    fn is_status_ok(&mut self) -> &mut T {

        self.expect_status_ok()

    }

    fn is_json(&mut self) -> &mut T {

        self.expect_content_type_json()

    }

    fn has_body(&mut self) -> &mut T { self.expect_body_present() }

}

```

## gRPC

Asserting gRPC is also supported with a [tonic](https://github.com/hyperium/tonic) client. Simply turn on the `tonic` 

feature and use it like this:

```rust

use asserhttp::grpc::*;

#[tokio::main]

async fn main() {

    // success

    client.call_svc(tonic::Request::new(Payload)).await.expect_status_ok().expect_body(Payload);

    // error

    client.call_svc(tonic::Request::new(Payload)).await.expect_status_error(Code::NotFound);

}

```