filter.rs - mozsearch

Enable keyboard shortcuts

#![deny(warnings)]

use std::convert::Infallible;

use warp::Filter;

#[tokio::test]

async fn flattens_tuples() {

    let _ = pretty_env_logger::try_init();

    let str1 = warp::any().map(|| "warp");

    let true1 = warp::any().map(|| true);

    let unit1 = warp::any();

    // just 1 value

    let ext = warp::test::request().filter(&str1).await.unwrap();

    assert_eq!(ext, "warp");

    // just 1 unit

    let ext = warp::test::request().filter(&unit1).await.unwrap();

    assert_eq!(ext, ());

    // combine 2 values

    let and = str1.and(true1);

    let ext = warp::test::request().filter(&and).await.unwrap();

    assert_eq!(ext, ("warp", true));

    // combine 2 reversed

    let and = true1.and(str1);

    let ext = warp::test::request().filter(&and).await.unwrap();

    assert_eq!(ext, (true, "warp"));

    // combine 1 with unit

    let and = str1.and(unit1);

    let ext = warp::test::request().filter(&and).await.unwrap();

    assert_eq!(ext, "warp");

    let and = unit1.and(str1);

    let ext = warp::test::request().filter(&and).await.unwrap();

    assert_eq!(ext, "warp");

    // combine 3 values

    let and = str1.and(str1).and(true1);

    let ext = warp::test::request().filter(&and).await.unwrap();

    assert_eq!(ext, ("warp", "warp", true));

    // combine 2 with unit

    let and = str1.and(unit1).and(true1);

    let ext = warp::test::request().filter(&and).await.unwrap();

    assert_eq!(ext, ("warp", true));

    let and = unit1.and(str1).and(true1);

    let ext = warp::test::request().filter(&and).await.unwrap();

    assert_eq!(ext, ("warp", true));

    let and = str1.and(true1).and(unit1);

    let ext = warp::test::request().filter(&and).await.unwrap();

    assert_eq!(ext, ("warp", true));

    // nested tuples

    let str_true_unit = str1.and(true1).and(unit1);

    let unit_str_true = unit1.and(str1).and(true1);

    let and = str_true_unit.and(unit_str_true);

    let ext = warp::test::request().filter(&and).await.unwrap();

    assert_eq!(ext, ("warp", true, "warp", true));

    let and = unit_str_true.and(unit1).and(str1).and(str_true_unit);

    let ext = warp::test::request().filter(&and).await.unwrap();

    assert_eq!(ext, ("warp", true, "warp", "warp", true));

#[tokio::test]

async fn map() {

    let _ = pretty_env_logger::try_init();

    let ok = warp::any().map(warp::reply);

    let req = warp::test::request();

    let resp = req.reply(&ok).await;

    assert_eq!(resp.status(), 200);

#[tokio::test]

async fn or() {

    let _ = pretty_env_logger::try_init();

    // Or can be combined with an infallible filter

    let a = warp::path::param::<u32>();

    let b = warp::any().map(|| 41i32);

    let f = a.or(b);

    let _: Result<_, Infallible> = warp::test::request().filter(&f).await;

#[tokio::test]

async fn or_else() {

    let _ = pretty_env_logger::try_init();

    let a = warp::path::param::<u32>();

    let f = a.or_else(|_| async { Ok::<_, warp::Rejection>((44u32,)) });

    assert_eq!(

        warp::test::request().path("/33").filter(&f).await.unwrap(),

33,

);

    assert_eq!(warp::test::request().filter(&f).await.unwrap(), 44,);

    // OrElse can be combined with an infallible filter

    let a = warp::path::param::<u32>();

    let f = a.or_else(|_| async { Ok::<_, Infallible>((44u32,)) });

    let _: Result<_, Infallible> = warp::test::request().filter(&f).await;

#[tokio::test]

async fn recover() {

    let _ = pretty_env_logger::try_init();

    let a = warp::path::param::<String>();

    let f = a.recover(|err| async move { Err::<String, _>(err) });

    // not rejected

    let resp = warp::test::request().path("/hi").reply(&f).await;

    assert_eq!(resp.status(), 200);

    assert_eq!(resp.body(), "hi");

    // rejected, recovered, re-rejected

    let resp = warp::test::request().reply(&f).await;

    assert_eq!(resp.status(), 404);

    // Recover can be infallible

    let f = a.recover(|_| async move { Ok::<_, Infallible>("shh") });

    let _: Result<_, Infallible> = warp::test::request().filter(&f).await;

#[tokio::test]

async fn unify() {

    let _ = pretty_env_logger::try_init();

    let a = warp::path::param::<u32>();

    let b = warp::path::param::<u32>();

    let f = a.or(b).unify();

    let ex = warp::test::request().path("/1").filter(&f).await.unwrap();

    assert_eq!(ex, 1);

#[should_panic]

#[tokio::test]

async fn nested() {

    let f = warp::any().and_then(|| async {

        let p = warp::path::param::<u32>();

        warp::test::request().filter(&p).await

});

    let _ = warp::test::request().filter(&f).await;