A server that stashes your requests for later retrieval to so you can do end-to-end testing of code that makes HTTP calls. Available as a binary, a Docker image, and a library.
Switch branches/tags
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
src
tests
.gitignore
.travis.yml
Cargo.toml
Dockerfile
LICENCE
Makefile
README.md
ca-certificates.crt
entry.sh
rusqbin-demo.gif

README.md

Rusqbin Build Status Crates.io

Rusqbin is a web server that stashes your requests for later retrieval. It is available as a Docker image, a binary, and a library through crates.io.

Rusdocs are published for:

Usage

Web API

The web server has the following API for dealing with request bins.

  • POST /rusqbins To create a bin and get back bin_id
  • GET /rusqbins To list bin summaries
  • GET /rusqbins/${bin_id} To get bin-specific summary information
  • GET /rusqbins/${bin_id}/requests To get detailed request information for a bin (lists all requests in the bin)
  • DELETE /rusqbins/${bin_id} To delete a bin

In any other case, send requests with a X-Rusqbin-Id header with a bin_id to have your requests logged to a bin for later retrieval.

Docker

$ docker run lloydmeta/rusqbin:latest

Binary

To use Rusqbin as a binary, simply install it using cargo install rusqbin and then run rusqbin, and follow the simple usage instructions. The port the server runs on can be set by optionally adding a port argument.

Binary usage demo

Logging is handled by env_logger, so you can configure it at runtime using a RUST_LOG environment variable.

Library

To use it as a library, add it to your project as a crate dependency, then from within Rust code:

use rusqbin::storage::*;
use rusqbin::server::*;
use rusqbin::models::*;
use hyper::{Method, Uri};
use hyper::client::Client;
use hyper::client::Request as HyperRequest;
use std::io::Read;
use std::thread;
use std::sync::{Arc, Mutex};
use std::str::FromStr;
use futures::future;

// Start a BinsServer on port 7000 in another thread, utilising
// a simple mutex for shutting it down. A channel could also work.
let server = Arc::new(BinsServer::new(7000, InMemoryBins::new()));
let arc_stay_alive = Arc::new(Mutex::new(true));
let bg_server = server.clone();
let bg_stay_alive = arc_stay_alive.clone();
thread::spawn(move || {
  bg_server.run_until(future::poll_fn(|| {
    if *bg_stay_alive.lock().unwrap() {
      Ok(futures::Async::NotReady)
    } else {
      Ok(futures::Async::Ready(()))
    }
  }))
});

let mut client_core = tokio_core::reactor::Core::new().unwrap();
let client = Client::new(&client_core.handle());

// Create a bin via programmatically, making sure to scope the
// storage unlocking with braces properly
let bin = {
  let mut server_storage = server.storage.lock().unwrap();
  server_storage.create_bin()
};
let bin_id = bin.id.value();

// Fire an HTTP request with the proper X-Rusqbin-Id header
let mut req = HyperRequest::new(Method::Post, Uri::from_str("http://localhost:7000/hello/world").unwrap());
req.headers_mut().set(XRusqBinId(bin_id.to_owned()));
let future_resp = client.request(req);

// Here we use core.run to block on response, but you should never
// do this in production code.
client_core.run(future_resp);
// Check to make sure our HTTP request was received and stashed
// in our rusqbin server
{
  let mut server_storage = server.storage.lock().unwrap();
  let bin_requests: &Bin = server_storage.get_bin(&bin.id).unwrap();
  let req = &bin_requests[0];
  assert_eq!(req.method, "POST".to_owned());
  assert_eq!(req.path, "/hello/world".to_owned());
}
// Cleanup by shutting down our server using the mutex
*arc_stay_alive.lock().unwrap() = false;

In the example above, we use the out-of-the-box InMemoryBins for storage, but you can pass any given implementation of rusqbin::storage::Bins when creating a BinsServer.

Credit

Rusqbin is a simple port of Requestbin written in Rust. Inspired by Requestinator