You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: user.rs
    path of file: ./repos/sqlx/examples/postgres/axum-social-with-tests/tests
    
    the code of the file until where you have to start completion: use sqlx::PgPool;

use sqlx_example_postgres_axum_social::http;

use axum::http::{Request, StatusCode};
use tower::ServiceExt;

use std::borrow::BorrowMut;

use common::{response_json, RequestBuilderExt};

use serde_json::json;

mod common;

#[sqlx::test]
async fn test_create_user(db: PgPool) {
    let mut app = http::app(db);

    // Happy path!
    let resp1 = app
        .borrow_mut()
        // We handle JSON objects directly to sanity check the serialization and deserialization
        .oneshot(Request::post("/v1/user").json(json! {{
            "username": "alice",
            "password": "rustacean since 2015"
        }}))
        .await
        .unwrap();

    assert_eq!(resp1.status(), StatusCode::NO_CONTENT);

    // Username taken
    let mut resp2 = app
        .borrow_mut()
        .oneshot(Request::post("/v1/user").json(json! {{
            "username": "alice",
            "password": "uhhh i forgot"
        }}))
        .await
        .unwrap();

    assert_eq!(resp2.status(), StatusCode::CONFLICT);

    let resp2_json = response_json(&mut resp2).await;
    assert_eq!(resp2_json["message"], "username taken");

    // Invalid username
    let mut resp3 = app
        .borrow_mut()
        .oneshot(Request::post("/v1/user").json(json! {{
            "username": "definitely an invalid username",
            "password": "password"
        }}))
        .await
        .unwrap();

    assert_eq!(resp3.status(), StatusCode::UNPROCESSABLE_ENTITY);

    let 
    
async fn test_create_user(db: PgPool) {
    let mut app = http::app(db);

    // Happy path!
    let resp1 = app
        .borrow_mut()
        // We handle JSON objects directly to sanity check the serialization and deserialization
        .oneshot(Request::post("/v1/user").json(json! {{
            "username": "alice",
            "password": "rustacean since 2015"
        }}))
        .await
        .unwrap();

    assert_eq!(resp1.status(), StatusCode::NO_CONTENT);

    // Username taken
    let mut resp2 = app
        .borrow_mut()
        .oneshot(Request::post("/v1/user").json(json! {{
            "username": "alice",
            "password": "uhhh i forgot"
        }}))
        .await
        .unwrap();

    assert_eq!(resp2.status(), StatusCode::CONFLICT);

    let resp2_json = response_json(&mut resp2).await;
    assert_eq!(resp2_json["message"], "username taken");

    // Invalid username
    let mut resp3 = app
        .borrow_mut()
        .oneshot(Request::post("/v1/user").json(json! {{
            "username": "definitely an invalid username",
            "password": "password"
        }}))
        .await
        .unwrap();

    assert_eq!(resp3.status(), StatusCode::UNPROCESSABLE_ENTITY);

    let resp3_json = response_json(&mut resp3).await;

    assert_eq!(resp3_json["message"], "validation error in request body");
    assert!(
        resp3_json["errors"]["username"].is_array(),
        "errors.username is not an array: {:?}",
        resp3_json
    );

    // Invalid password
    let mut resp4 = app
        .borrow_mut()
        .oneshot(Request::post("/v1/user").json(json! {{
            "username": "bobby123",
            "password": ""
        }}))
        .await
        .unwrap();

    assert_eq!(resp4.status(), StatusCode::UNPROCESSABLE_ENTITY);

    let resp4_json = response_json(&mut resp4).await;

    assert_eq!(resp4_json["message"], "validation error in request body");
    assert!(
        resp4_json["errors"]["password"].is_array(),
        "errors.password is not an array: {:?}",
        resp4_json
    );
}