How to make TempFile serializable for tests

[lucasbasquerotto]

Hi, I was seeing the examples in this repository and testing them in my machine. They are very helpful and can be taken as reference for several use cases, so thanks for them!

One of the examples, tough, the forms example, doesn't have a test (it has a test file that is not imported and consequently not used, and its contents doesn't correspond to the main file). To make my understanding of the rocket framework deeper, I tried to create a test for it. Unfortunately I found some problems when I tried to implement.

1. Convert from T: FromForm to Form<Contextual<T>> and get the Context

The rocket framework provide a way to declare a parameter in a function as the type Form<Contextual<T>>. This parameter was used to get the context and populate the template with it. The problem is that this is done automatically by rocket, so I don't know how to create it from T.

I saw that the result has a values property that is an iterator of string representing the props flattened (as what is done when serializing for the content type www-form-urlencoded), so it has props like account.password.first, submission.title, etc. In the case of lists, it separates with a comma. Furthermore, its values are between [ and ].

This seems like an implementation detail of Rocket, so I was expecting a way to be able to do this with some utility function/trait using the main object (T), but I have found nothing. So I created a function to do that:

fn rocket_context<T: UriDisplay<Query>>(data: &T) -> HashMap<String, String> {
    let url_params = (data as &dyn UriDisplay<Query>).to_string();

    let hash_query: MultiMap<_, _> = url::form_urlencoded::parse(url_params.as_bytes()).collect();

    hash_query
        .into_iter()
        .map(|item| (item.0.to_string(), format!("[{}]", item.1.join(", "))))
        .collect()
}

I needed to import 2 dev-dependencies to do that:

[dev-dependencies]
url = "1.4.0"
multimap = "0.8.3"

The template expect the context values, so I create the context as

let hash_query = rocket_context(&data);

context! {
    values: hash_query
}

Considering that this seems like a rocket implementation detail, I was expecting a utility function or trait that creates Form<Contextual<T>> from a struct T: FromForm (and maybe using the request too, if needed), or at least the Context, without the need of external libs. Is there a way to do it?

2. Make TempFile implement UriDisplay<Query>

Even more important than the previous issue is that, for testing the request, I set the body with (&data as &dyn UriDisplay<Query>).to_string() (I took another example as a reference). This is to serialize the struct in the www-form-urlencoded format. For this to work, I made all structs derive UriDisplayQuery. Unfortunately, TempFile does not derive it (and it isn't serializable, so I think the same problem can happen with JSON).

How can I create a request in which the body is (based on) a struct with TempFile as one of the fields? As an alternative, how can I serialize a struct that has a TempFile in it? I could define a raw string for the whole body (be it a JSON or www-form-urlencoded body), but then I would lose rust type safety. This means that I could only do type safe tests in requests in which the body is the whole TempFile (in which case I could define the file contents as a string), but I wouldn't be able to do that if the file is not the whole body, but part of it (like this example, in which the file is a field in a struct).

---

The tests I created are as follows:

use std::collections::HashMap;

use super::{rocket, Account, Category, Password, Rights, Submission, Submit};
use multimap::MultiMap;
use rocket::form::Context;
use rocket::fs::TempFile;
use rocket::http::uri::fmt::{Query, UriDisplay};
use rocket::http::{ContentType, Status};
use rocket::local::blocking::Client;
use rocket_dyn_templates::{context, Template};

#[test]
fn test_index() {
    let client = Client::tracked(super::rocket()).unwrap();
    let response = client.get(uri!(super::index)).dispatch();

    let expected = Template::show(client.rocket(), "index", &Context::default());

    assert_eq!(response.status(), Status::Ok);
    assert_eq!(response.into_string(), expected);
}

#[test]
fn test_submit() {
    let client = Client::tracked(super::rocket()).unwrap();

    let data = Submit {
        account: Account {
            name: "My Name 01",
            password: Password {
                first: "pa$$w0rd",
                second: "pa$$w0rd",
            },
            email: "[email protected]",
        },
        submission: Submission {
            title: "Title #01",
            date: rocket::time::Date::MAX,
            r#abstract: "Abstract\nLine 02\nEnd",
            // file: TempFile::Buffered {
            //     content: "Some data...",
            // },
            category: vec![Category::Biology, Category::Chemistry],
            rights: Rights::Reserved,
            ready: true,
        },
    };

    let response = client
        .post(uri!(super::submit))
        .header(ContentType::Form)
        .body((&data as &dyn UriDisplay<Query>).to_string())
        .dispatch();

    let hash_query = rocket_context(&data);

    let expected = Template::show(
        client.rocket(),
        "success",
        context! {
            values: hash_query
        },
    );

    assert_eq!(response.status(), Status::Ok);
    assert_eq!(response.into_string(), expected);
}

#[test]
fn test_error() {
    let client = Client::tracked(super::rocket()).unwrap();

    let response = client
        .post(uri!(super::submit))
        .header(ContentType::JSON)
        .dispatch();

    assert_eq!(response.status(), Status::NotFound);

    let response = client
        .post(uri!(super::submit))
        .header(ContentType::Form)
        .dispatch();

    assert_eq!(response.status(), Status::UnprocessableEntity);

    let data = Submit {
        account: Account {
            name: "Long Abstract",
            password: Password {
                first: "pa$$w0rd",
                second: "pa$$w0rd",
            },
            email: "[email protected]",
        },
        submission: Submission {
            title: "Title #02",
            date: rocket::time::Date::MAX,
            r#abstract: &"0".repeat(251),
            // file: TempFile::Buffered {
            //     content: "Some data...",
            // },
            category: vec![Category::Biology, Category::ComputerScience],
            rights: Rights::Reserved,
            ready: true,
        },
    };

    let response = client
        .post(uri!(super::submit))
        .header(ContentType::Form)
        .body((&data as &dyn UriDisplay<Query>).to_string())
        .dispatch();

    assert_eq!(response.status(), Status::UnprocessableEntity);
}

fn rocket_context<T: UriDisplay<Query>>(data: &T) -> HashMap<String, String> {
    let url_params = (data as &dyn UriDisplay<Query>).to_string();

    let hash_query: MultiMap<_, _> = url::form_urlencoded::parse(url_params.as_bytes()).collect();

    hash_query
        .into_iter()
        .map(|item| (item.0.to_string(), format!("[{}]", item.1.join(", "))))
        .collect()
}

I added #[cfg_attr(test, derive(UriDisplayQuery))] to the structs of the main file, and commented the file field to be able to run the tests:

#[macro_use]
extern crate rocket;

use rocket::form::{Context, Contextual, Form, FromForm, FromFormField};
use rocket::fs::{relative, FileServer, TempFile};
use rocket::http::{ContentType, Status};
use rocket::time::Date;

use rocket_dyn_templates::Template;

#[cfg(test)]
mod tests;

#[derive(Debug, FromForm)]
#[cfg_attr(test, derive(UriDisplayQuery))]
struct Password<'v> {
    #[field(validate = len(6..))]
    #[field(validate = eq(self.second))]
    first: &'v str,
    #[field(validate = eq(self.first))]
    second: &'v str,
}

#[derive(Debug, FromFormField)]
#[cfg_attr(test, derive(UriDisplayQuery))]
enum Rights {
    Public,
    Reserved,
    Exclusive,
}

#[derive(Debug, FromFormField)]
#[cfg_attr(test, derive(UriDisplayQuery))]
enum Category {
    Biology,
    Chemistry,
    Physics,
    #[field(value = "CS")]
    ComputerScience,
}

#[allow(dead_code)]
#[derive(Debug, FromForm)]
#[cfg_attr(test, derive(UriDisplayQuery))]
struct Submission<'v> {
    #[field(validate = len(1..))]
    title: &'v str,
    date: Date,
    #[field(validate = len(1..=250))]
    r#abstract: &'v str,
    // #[field(validate = ext(ContentType::PDF))]
    // file: TempFile<'v>,
    #[field(validate = len(1..))]
    category: Vec<Category>,
    rights: Rights,
    ready: bool,
}

#[allow(dead_code)]
#[derive(Debug, FromForm)]
#[cfg_attr(test, derive(UriDisplayQuery))]
struct Account<'v> {
    #[field(validate = len(1..))]
    name: &'v str,
    password: Password<'v>,
    #[field(validate = contains('@').or_else(msg!("invalid email address")))]
    email: &'v str,
}

#[allow(dead_code)]
#[derive(Debug, FromForm)]
#[cfg_attr(test, derive(UriDisplayQuery))]
struct Submit<'v> {
    account: Account<'v>,
    submission: Submission<'v>,
}

#[get("/")]
fn index() -> Template {
    Template::render("index", &Context::default())
}

// NOTE: We use `Contextual` here because we want to collect all submitted form
// fields to re-render forms with submitted values on error. If you have no such
// need, do not use `Contextual`. Use the equivalent of `Form<Submit<'_>>`.
#[post("/", data = "<form>")]
fn submit<'r>(form: Form<Contextual<'r, Submit<'r>>>) -> (Status, Template) {
    let template = match form.value {
        Some(ref submission) => {
            println!("submission: {:#?}", submission);
            Template::render("success", &form.context)
        }
        None => Template::render("index", &form.context),
    };

    (form.context.status(), template)
}

#[launch]
fn rocket() -> _ {
    rocket::build()
        .mount("/", routes![index, submit])
        .attach(Template::fairing())
        .mount("/", FileServer::from(relative!("/static")))
}

If I uncomment the file field, I receive the error:

the trait bound `TempFile<'_>: UriDisplay<rocket::http::uri::fmt::Query>` is not satisfied
required because of the requirements on the impl of `UriDisplay<rocket::http::uri::fmt::Query>` for `&TempFile<'_>`

which is related to the issue 2.

Thanks, in advance.