oslo/tests/auth.rs

mod tests {
    use std::path::PathBuf;

    use async_std::task::block_on;
    use oslo_lib::{hash_password, State};
    use serde_json::json;
    use tide::{
        http::{Method, Request, Response, StatusCode, Url},
        Result, Server,
    };

    async fn build_app() -> Server<State> {
        std::env::set_var("ADMIN_USERNAME", "correct_username".to_string());
        std::env::set_var(
            "ADMIN_PASSWORD",
            hash_password("correct_password", "correct_username"),
        );
        oslo_lib::build_app().await.unwrap()
    }

    fn url(path: &str) -> Url {
        Url::parse("http://localhost:8080")
            .unwrap()
            .join(path)
            .unwrap()
    }

    #[test]
    fn test_login_page() -> Result<()> {
        block_on(async {
            let app = build_app().await;
            let req = Request::new(Method::Get, url("login"));
            let mut res: Response = app.respond(req).await?;
            assert_eq!(res.status(), 200);
            assert!(res.body_string().await?.contains("Login"));
            Ok(())
        })
    }

    #[test]
    fn test_logging_in() -> Result<()> {
        block_on(async {
            let app = build_app().await;
            let mut req = Request::new(Method::Post, url("login"));
            req.set_content_type(tide::http::mime::MULTIPART_FORM);
            let username = String::from("correct_username");
            let password = String::from("correct_password");
            req.replace_body(format!("username={}&password={}", username, password));
            let res: Response = app.respond(req).await?;
            assert_eq!(res.status(), StatusCode::Found);
            assert_eq!(res.header("location").unwrap(), "/");
            Ok(())
        })
    }

    #[test]
    fn test_invalid_credentials() -> Result<()> {
        block_on(async {
            let app = build_app().await;
            let mut req = Request::new(Method::Post, url("login"));
            req.set_content_type(tide::http::mime::MULTIPART_FORM);
            req.replace_body("username=invalid&password=credentials");
            let res: Response = app.respond(req).await?;
            assert_eq!(res.status(), StatusCode::Found);
            assert_eq!(res.header("location").unwrap(), "/login");
            Ok(())
        })
    }

    #[test]
    fn test_accessing_protected_route_as_guest() -> Result<()> {
        block_on(async {
            let app = build_app().await;
            let req = Request::new(Method::Get, url("/posts/1/edit"));
            let res: Response = app.respond(req).await?;
            assert_eq!(res.status(), StatusCode::Found);
            assert_eq!(res.header("location").unwrap(), "/login");
            Ok(())
        })
    }

    #[test]
    fn test_attempting_to_create_post_as_guest() -> Result<()> {
        block_on(async {
            let app = build_app().await;
            let mut req = Request::new(Method::Post, url("/posts"));
            req.set_content_type(tide::http::mime::MULTIPART_FORM);
            req.replace_body("title=test1&slug=test1&body=test1");
            let res: Response = app.respond(req).await?;
            assert_eq!(res.status(), StatusCode::Found);
            assert_eq!(res.header("location").unwrap(), "/login");
            Ok(())
        })
    }

    #[test]
    fn test_attempting_to_update_post_as_guest() -> Result<()> {
        let data = json!({
            "title":"test1",
            "slug":"test1",
            "body":"test1",
            "html":"<p>test1</p>\n",
            "date":"2000-01-01",
            "draft":0
        });
        block_on(async {
            let app = build_app().await;
            let posts_dir = std::env::var("POSTS_DIR")?;
            let path = PathBuf::from(posts_dir);
            let path = path.join("test1.json");
            std::fs::write(&path, data.to_string())?;
            let mut req = Request::new(Method::Post, url("/posts/test1"));
            req.set_content_type(tide::http::mime::MULTIPART_FORM);
            req.replace_body("title=test1&slug=test1&body=test2");
            let res: Response = app.respond(req).await?;
            assert_eq!(res.status(), StatusCode::Found);
            assert_eq!(res.header("location").unwrap(), "/login");
            assert_eq!(std::fs::read_to_string(&path)?, data.to_string());
            std::fs::remove_file(&path)?;
            Ok(())
        })
    }

    #[test]
    fn test_attempting_to_delete_post_as_guest() -> Result<()> {
        let data = json!({
            "title":"test2",
            "slug":"test2",
            "body":"test2",
            "html":"<p>test2</p>\n",
            "date":"2000-01-01",
            "draft":0
        });
        block_on(async {
            let app = build_app().await;
            let posts_dir = std::env::var("POSTS_DIR")?;
            let path = PathBuf::from(posts_dir);
            let path = path.join("test2.json");
            std::fs::write(&path, data.to_string())?;
            let req = Request::new(Method::Delete, url("/posts/test2"));
            let res: Response = app.respond(req).await?;
            assert_eq!(res.status(), StatusCode::Found);
            assert_eq!(res.header("location").unwrap(), "/login");
            assert_eq!(std::fs::read_to_string(&path)?, data.to_string());
            std::fs::remove_file(&path)?;
            Ok(())
        })
    }
}