mod common;
pub use common::*;
use rocket::http::Status;
#[tokio::test]
async fn unauthenticated_apply_denied() {
    let client = common::testing_client().await;
    let db = rocket::State::get(&client.rocket()).expect("managed database");
    let project = common::project(db).await;
    let resp = client.post(format!("/{}/{}/.pijul?ABCD", project.owner(db).await.unwrap().name, project.name))
        .dispatch().await;
    assert_eq!(resp.status(), Status::NotFound);
}

    use rand::Rng;
    const CHARSET: &[u8] = b"abcdefghijklmnopqrstuvwxyz0123456789";
    let mut rng = rand::thread_rng();
    let username: String = (0..12)
        .map(|_| {
            let idx = rng.gen_range(0..CHARSET.len());
            CHARSET[idx] as char
        })
        .collect();

    let username = random_name();

use nidobyte::models::projects;
pub async fn project(db: &rocket::State<Database>) -> projects::Project {
    let owner = user(db).await;
    projects::create(db, owner.id, random_name()).await.unwrap()
}
use rand::Rng;
fn random_name() -> String {
    const CHARSET: &[u8] = b"abcdefghijklmnopqrstuvwxyz0123456789";
    let mut rng = rand::thread_rng();
    (0..12) .map(|_| {
            let idx = rng.gen_range(0..CHARSET.len());
            CHARSET[idx] as char
        })
        .collect()
}

impl PartialEq for User {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}
impl Eq for User {}

        self.owner(db).await
    }
    pub async fn owner(&self, db: &State<Database>) -> Result<User> {

        Ok(Repository::init_or_open(root, self.repo_path())?)

        Ok(Repository::init_or_open(self, root)?)

    fn repo_path(&self) -> std::path::PathBuf {

    pub fn repo_path(&self) -> std::path::PathBuf {

use crate::models::pijul::changestores::Changestore;

use crate::models::{pijul::changestores::Changestore, users::User, projects::Project};
use crate::database::Database;

pub struct Repository {

pub struct Repository<'r> {

    project: &'r Project,

impl Repository {

impl <'r>Repository<'r> {

    fn new(full_path: PathBuf) -> Repository {

    fn new(project: &Project, full_path: PathBuf) -> Repository {

            project: project,

    pub fn init_or_open(root: &PathBuf, repo_path: PathBuf) -> Result<Self, anyhow::Error> {
        let repo = Self::new(root.join(repo_path));

    pub fn init_or_open(project: &'r Project, root: &PathBuf) -> Result<Self, anyhow::Error> {
        let repo = Self::new(project, root.join(project.repo_path()));

    pub async fn owner(&self, db: &rocket::State<Database>) -> anyhow::Result<User> {
        self.project.owner(db).await
    }

mod authz;

// succeeded.

// succeeded. When a user cannot be authenticated the status code is 404 to hide the existence of
// the repository.

    current_user: crate::models::users::User,

    if !crate::authz::can_apply_patch(db, &current_user, &repo).await {
        return rocket::http::Status::Unauthorized;
    }

use crate::models::{pijul::repositories::Repository, users::User};
pub async fn can_apply_patch(
    db: &rocket::State<crate::database::Database>,
    user: &User,
    repo: &Repository<'_>,
) -> bool {
    let owner = repo.owner(db).await;
    
    owner.is_ok() && owner.unwrap()  == *user
}