Struct Client

pub struct Client {
    pub base_url: String,
    /* private fields */
}

The HTTP client

Fields

base_url: String

API base URL

Implementations

impl Client

pub fn new(base_url: String) -> Client

Create a new instance of a Client

Usage:

use roy::Client;

let c = Client::new("https://httpbin.org".to_string());
assert_eq!(c.base_url, "https://httpbin.org");

pub fn new_auth(base_url: String, auth_token: String) -> Client

Create a new instance of an authenticated Client

Usage:

use roy::Client;
use tokio_test::block_on;

let c = Client::new_auth("https://httpbin.org".to_string(), "".to_string());
assert_eq!(block_on(c.get("/bearer", false)).is_some(), true);

pub async fn post<T: Serialize + Debug>( &self, endpoint: &str, data: T, ) -> Option<Response>

Generic function to POST data to an endpoint

Usage:

use roy::Client;
use tokio_test::block_on;

let c = Client::new("https://httpbin.org".to_string());
assert_eq!(block_on(c.post("/post", "{data}")).is_some(), true);

pub async fn delete(&self, endpoint: &str) -> Option<Response>

Generic function to DELETE to an endpoint

Usage:

use roy::Client;
use tokio_test::block_on;

let c = Client::new("https://httpbin.org".to_string());
assert_eq!(block_on(c.delete("/delete")).is_some(), true);

pub async fn patch<T: Serialize + Debug>( &self, endpoint: &str, data: T, ) -> Option<Response>

Generic function to PATCH data to an endpoint

Usage:

use roy::Client;
use tokio_test::block_on;

let c = Client::new("https://httpbin.org".to_string());
assert_eq!(block_on(c.patch("/patch", "{data}")).is_some(), true);

pub async fn put<T: Serialize + Debug>( &self, endpoint: &str, data: T, ) -> Option<Response>

Generic function to PUT data to an endpoint

Usage:

use roy::Client;
use tokio_test::block_on;

let c = Client::new("https://httpbin.org".to_string());
assert_eq!(block_on(c.put("/put", "{data}")).is_some(), true);

pub async fn get(&self, endpoint: &str, single: bool) -> Option<Response>

Generic function to send a GET request to an endpoint

Usage:

use roy::Client;
use tokio_test::block_on;

let c = Client::new("https://httpbin.org".to_string());
assert_eq!(block_on(c.get("/get", false)).is_some(), true);

pub async fn get_abs(&self, url: &str, single: bool) -> Option<Response>

Generic function to send a GET request to an endpoint without formating to use the base url.

Regardless of the value of base_url, this function will send a GET request to the absolute URL passed as the url parameter.

Usage:

use roy::Client;
use tokio_test::block_on;

let c = Client::new("https://doesnotexist.example.io".to_string());
assert_eq!(block_on(c.get_abs("https://httpbin.org", false)).is_some(), true);

pub fn format_url(&self, endpoint: &str) -> String

Format a URL

Usage:

use roy::Client;

let c = Client::new("https://httpbin.org".to_string());
assert_eq!(c.format_url("/test"), "https://httpbin.org/test")

pub async fn request( &self, endpoint: &str, method: RequestMethod, data: Option<&str>, ) -> Option<Response>

Make a request to the specified endpoint with a specified request method.

Usage:

use roy::{Client, RequestMethod};
use tokio_test::block_on;

let c = Client::new("https://httpbin.org".to_string());

assert!(block_on(c.request("/get", RequestMethod::GET, None)).is_some());
assert!(block_on(c.request("/post", RequestMethod::POST, Some("{}"))).is_some());
assert!(block_on(c.request("/patch", RequestMethod::PATCH, Some("{}"))).is_some());
assert!(block_on(c.request("/put", RequestMethod::PUT, Some("{}"))).is_some());
assert!(block_on(c.request("/delete", RequestMethod::DELETE, None)).is_some());