gitbutler/gitbutler-app/tests/virtual_branches.rs

//TODO:
#![allow(
    clippy::redundant_closure_for_method_calls,
    clippy::rest_pat_in_fully_bound_structs,
    clippy::dbg_macro
)]

mod common;

use std::{fs, path, str::FromStr};

use gblib::{
    error::Error,
    git, keys,
    projects::{self, ProjectId},
    users,
    virtual_branches::{branch, controller::ControllerError, errors, Controller},
};

use self::common::{paths, TestProject};

struct Test {
    repository: TestProject,
    project_id: ProjectId,
    projects: projects::Controller,
    controller: Controller,
}

impl Default for Test {
    fn default() -> Self {
        let data_dir = paths::data_dir();
        let keys = keys::Controller::from(&data_dir);
        let projects = projects::Controller::from(&data_dir);
        let users = users::Controller::from(&data_dir);
        let helper = git::credentials::Helper::from(&data_dir);

        let test_project = TestProject::default();
        let project = projects
            .add(test_project.path())
            .expect("failed to add project");

        Self {
            repository: test_project,
            project_id: project.id,
            controller: Controller::new(&data_dir, &projects, &users, &keys, &helper),
            projects,
        }
    }
}

mod create_commit {
    use super::*;

    #[tokio::test]
    async fn should_lock_updated_hunks() {
        let Test {
            project_id,
            controller,
            repository,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            // by default, hunks are not locked

            fs::write(repository.path().join("file.txt"), "content").unwrap();

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert_eq!(branch.files.len(), 1);
            assert_eq!(branch.files[0].path.display().to_string(), "file.txt");
            assert_eq!(branch.files[0].hunks.len(), 1);
            assert!(!branch.files[0].hunks[0].locked);
        }

        controller
            .create_commit(&project_id, &branch_id, "test", None, false)
            .await
            .unwrap();

        {
            // change in the committed hunks leads to hunk locking
            fs::write(repository.path().join("file.txt"), "updated content").unwrap();

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert_eq!(branch.files.len(), 1);
            assert_eq!(branch.files[0].path.display().to_string(), "file.txt");
            assert_eq!(branch.files[0].hunks.len(), 1);
            assert!(branch.files[0].hunks[0].locked);
        }
    }

    #[tokio::test]
    async fn should_not_lock_disjointed_hunks() {
        let Test {
            project_id,
            controller,
            repository,
            ..
        } = Test::default();

        let mut lines: Vec<_> = (0_i32..24_i32).map(|i| format!("line {}", i)).collect();
        fs::write(repository.path().join("file.txt"), lines.clone().join("\n")).unwrap();
        repository.commit_all("my commit");
        repository.push();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            // new hunk in the middle of the file
            lines[12] = "commited stuff".to_string();
            fs::write(repository.path().join("file.txt"), lines.clone().join("\n")).unwrap();
            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert_eq!(branch.files.len(), 1);
            assert_eq!(branch.files[0].path.display().to_string(), "file.txt");
            assert_eq!(branch.files[0].hunks.len(), 1);
            assert!(!branch.files[0].hunks[0].locked);
        }

        controller
            .create_commit(&project_id, &branch_id, "test commit", None, false)
            .await
            .unwrap();
        controller
            .push_virtual_branch(&project_id, &branch_id, false)
            .await
            .unwrap();

        {
            // hunk before the commited part is not locked
            let mut changed_lines = lines.clone();
            changed_lines[0] = "updated line\nwith extra line".to_string();
            fs::write(repository.path().join("file.txt"), changed_lines.join("\n")).unwrap();
            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert_eq!(branch.files.len(), 1);
            assert_eq!(branch.files[0].path.display().to_string(), "file.txt");
            assert_eq!(branch.files[0].hunks.len(), 1);
            assert!(!branch.files[0].hunks[0].locked);
            // cleanup
            fs::write(repository.path().join("file.txt"), lines.clone().join("\n")).unwrap();
        }
        {
            // hunk after the commited part is not locked
            let mut changed_lines = lines.clone();
            changed_lines[23] = "updated line".to_string();
            fs::write(repository.path().join("file.txt"), changed_lines.join("\n")).unwrap();
            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert_eq!(branch.files.len(), 1);
            assert_eq!(branch.files[0].path.display().to_string(), "file.txt");
            assert_eq!(branch.files[0].hunks.len(), 1);
            assert!(!branch.files[0].hunks[0].locked);
            // cleanup
            fs::write(repository.path().join("file.txt"), lines.clone().join("\n")).unwrap();
        }
        {
            // hunk before the commited part but with overlapping context
            let mut changed_lines = lines.clone();
            changed_lines[10] = "updated line".to_string();
            fs::write(repository.path().join("file.txt"), changed_lines.join("\n")).unwrap();
            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert_eq!(branch.files.len(), 1);
            assert_eq!(branch.files[0].path.display().to_string(), "file.txt");
            assert_eq!(branch.files[0].hunks.len(), 1);
            assert!(!branch.files[0].hunks[0].locked);
            // cleanup
            fs::write(repository.path().join("file.txt"), lines.clone().join("\n")).unwrap();
        }
        {
            // hunk after the commited part but with overlapping context
            let mut changed_lines = lines.clone();
            changed_lines[14] = "updated line".to_string();
            fs::write(repository.path().join("file.txt"), changed_lines.join("\n")).unwrap();
            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert_eq!(branch.files.len(), 1);
            assert_eq!(branch.files[0].path.display().to_string(), "file.txt");
            assert_eq!(branch.files[0].hunks.len(), 1);
            assert!(!branch.files[0].hunks[0].locked);
            // cleanup
            fs::write(repository.path().join("file.txt"), lines.clone().join("\n")).unwrap();
        }
    }
}

mod references {
    use super::*;

    mod create_virtual_branch {
        use super::*;

        #[tokio::test]
        async fn simple() {
            let Test {
                project_id,
                controller,
                repository,
                ..
            } = Test::default();

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch_id);
            assert_eq!(branches[0].name, "Virtual branch");

            let refnames = repository
                .references()
                .into_iter()
                .filter_map(|reference| reference.name().map(|name| name.to_string()))
                .collect::<Vec<_>>();
            assert!(refnames.contains(&"refs/gitbutler/virtual-branch".to_string()));
        }

        #[tokio::test]
        async fn duplicate_name() {
            let Test {
                project_id,
                controller,
                repository,
                ..
            } = Test::default();

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch1_id = controller
                .create_virtual_branch(
                    &project_id,
                    &gblib::virtual_branches::branch::BranchCreateRequest {
                        name: Some("name".to_string()),
                        ..Default::default()
                    },
                )
                .await
                .unwrap();

            let branch2_id = controller
                .create_virtual_branch(
                    &project_id,
                    &gblib::virtual_branches::branch::BranchCreateRequest {
                        name: Some("name".to_string()),
                        ..Default::default()
                    },
                )
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 2);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].name, "name");
            assert_eq!(branches[1].id, branch2_id);
            assert_eq!(branches[1].name, "name 1");

            let refnames = repository
                .references()
                .into_iter()
                .filter_map(|reference| reference.name().map(|name| name.to_string()))
                .collect::<Vec<_>>();
            assert!(refnames.contains(&"refs/gitbutler/name".to_string()));
            assert!(refnames.contains(&"refs/gitbutler/name-1".to_string()));
        }
    }

    mod update_virtual_branch {
        use super::*;

        #[tokio::test]
        async fn simple() {
            let Test {
                project_id,
                controller,
                repository,
                ..
            } = Test::default();

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = controller
                .create_virtual_branch(
                    &project_id,
                    &branch::BranchCreateRequest {
                        name: Some("name".to_string()),
                        ..Default::default()
                    },
                )
                .await
                .unwrap();

            controller
                .update_virtual_branch(
                    &project_id,
                    branch::BranchUpdateRequest {
                        id: branch_id,
                        name: Some("new name".to_string()),
                        ..Default::default()
                    },
                )
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch_id);
            assert_eq!(branches[0].name, "new name");

            let refnames = repository
                .references()
                .into_iter()
                .filter_map(|reference| reference.name().map(|name| name.to_string()))
                .collect::<Vec<_>>();
            assert!(!refnames.contains(&"refs/gitbutler/name".to_string()));
            assert!(refnames.contains(&"refs/gitbutler/new-name".to_string()));
        }

        #[tokio::test]
        async fn duplicate_name() {
            let Test {
                project_id,
                controller,
                repository,
                ..
            } = Test::default();

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch1_id = controller
                .create_virtual_branch(
                    &project_id,
                    &branch::BranchCreateRequest {
                        name: Some("name".to_string()),
                        ..Default::default()
                    },
                )
                .await
                .unwrap();

            let branch2_id = controller
                .create_virtual_branch(
                    &project_id,
                    &branch::BranchCreateRequest {
                        ..Default::default()
                    },
                )
                .await
                .unwrap();

            controller
                .update_virtual_branch(
                    &project_id,
                    branch::BranchUpdateRequest {
                        id: branch2_id,
                        name: Some("name".to_string()),
                        ..Default::default()
                    },
                )
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 2);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].name, "name");
            assert_eq!(branches[1].id, branch2_id);
            assert_eq!(branches[1].name, "name 1");

            let refnames = repository
                .references()
                .into_iter()
                .filter_map(|reference| reference.name().map(|name| name.to_string()))
                .collect::<Vec<_>>();
            assert!(refnames.contains(&"refs/gitbutler/name".to_string()));
            assert!(refnames.contains(&"refs/gitbutler/name-1".to_string()));
        }
    }

    mod push_virtual_branch {
        use super::*;

        #[tokio::test]
        async fn simple() {
            let Test {
                project_id,
                controller,
                repository,
                ..
            } = Test::default();

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch1_id = controller
                .create_virtual_branch(
                    &project_id,
                    &branch::BranchCreateRequest {
                        name: Some("name".to_string()),
                        ..Default::default()
                    },
                )
                .await
                .unwrap();

            fs::write(repository.path().join("file.txt"), "content").unwrap();

            controller
                .create_commit(&project_id, &branch1_id, "test", None, false)
                .await
                .unwrap();
            controller
                .push_virtual_branch(&project_id, &branch1_id, false)
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].name, "name");
            assert_eq!(
                branches[0].upstream.as_ref().unwrap().name.to_string(),
                "refs/remotes/origin/name"
            );

            let refnames = repository
                .references()
                .into_iter()
                .filter_map(|reference| reference.name().map(|name| name.to_string()))
                .collect::<Vec<_>>();
            assert!(refnames.contains(&branches[0].upstream.clone().unwrap().name.to_string()));
        }

        #[tokio::test]
        async fn duplicate_names() {
            let Test {
                project_id,
                controller,
                repository,
                ..
            } = Test::default();

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch1_id = {
                // create and push branch with some work
                let branch1_id = controller
                    .create_virtual_branch(
                        &project_id,
                        &branch::BranchCreateRequest {
                            name: Some("name".to_string()),
                            ..Default::default()
                        },
                    )
                    .await
                    .unwrap();
                fs::write(repository.path().join("file.txt"), "content").unwrap();
                controller
                    .create_commit(&project_id, &branch1_id, "test", None, false)
                    .await
                    .unwrap();
                controller
                    .push_virtual_branch(&project_id, &branch1_id, false)
                    .await
                    .unwrap();
                branch1_id
            };

            // rename first branch
            controller
                .update_virtual_branch(
                    &project_id,
                    branch::BranchUpdateRequest {
                        id: branch1_id,
                        name: Some("updated name".to_string()),
                        ..Default::default()
                    },
                )
                .await
                .unwrap();

            let branch2_id = {
                // create another branch with first branch's old name and push it
                let branch2_id = controller
                    .create_virtual_branch(
                        &project_id,
                        &branch::BranchCreateRequest {
                            name: Some("name".to_string()),
                            ..Default::default()
                        },
                    )
                    .await
                    .unwrap();
                fs::write(repository.path().join("file.txt"), "updated content").unwrap();
                controller
                    .create_commit(&project_id, &branch2_id, "test", None, false)
                    .await
                    .unwrap();
                controller
                    .push_virtual_branch(&project_id, &branch2_id, false)
                    .await
                    .unwrap();
                branch2_id
            };

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 2);
            // first branch is pushing to old ref remotely
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].name, "updated name");
            assert_eq!(
                branches[0].upstream.as_ref().unwrap().name,
                "refs/remotes/origin/name".parse().unwrap()
            );
            // new branch is pushing to new ref remotely
            assert_eq!(branches[1].id, branch2_id);
            assert_eq!(branches[1].name, "name");
            assert_eq!(
                branches[1].upstream.as_ref().unwrap().name,
                "refs/remotes/origin/name-1".parse().unwrap()
            );

            let refnames = repository
                .references()
                .into_iter()
                .filter_map(|reference| reference.name().map(|name| name.to_string()))
                .collect::<Vec<_>>();
            assert!(refnames.contains(&branches[0].upstream.clone().unwrap().name.to_string()));
            assert!(refnames.contains(&branches[1].upstream.clone().unwrap().name.to_string()));
        }
    }
}

mod delete_virtual_branch {
    use super::*;

    #[tokio::test]
    async fn should_unapply_diff() {
        let Test {
            project_id,
            controller,
            repository,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        // write some
        std::fs::write(repository.path().join("file.txt"), "content").unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();

        controller
            .delete_virtual_branch(&project_id, &branches[0].id)
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 0);
        assert!(!repository.path().join("file.txt").exists());

        let refnames = repository
            .references()
            .into_iter()
            .filter_map(|reference| reference.name().map(|name| name.to_string()))
            .collect::<Vec<_>>();
        assert!(!refnames.contains(&"refs/gitbutler/name".to_string()));
    }

    #[tokio::test]
    async fn should_remove_reference() {
        let Test {
            project_id,
            controller,
            repository,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let id = controller
            .create_virtual_branch(
                &project_id,
                &branch::BranchCreateRequest {
                    name: Some("name".to_string()),
                    ..Default::default()
                },
            )
            .await
            .unwrap();

        controller
            .delete_virtual_branch(&project_id, &id)
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 0);

        let refnames = repository
            .references()
            .into_iter()
            .filter_map(|reference| reference.name().map(|name| name.to_string()))
            .collect::<Vec<_>>();
        assert!(!refnames.contains(&"refs/gitbutler/name".to_string()));
    }
}

mod set_base_branch {
    use super::*;

    use pretty_assertions::assert_eq;

    #[tokio::test]
    async fn success() {
        let Test {
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();
    }

    mod errors {
        use super::*;

        #[tokio::test]
        async fn missing() {
            let Test {
                project_id,
                controller,
                ..
            } = Test::default();

            assert!(matches!(
                controller
                    .set_base_branch(
                        &project_id,
                        &git::RemoteRefname::from_str("refs/remotes/origin/missing").unwrap(),
                    )
                    .await,
                Err(Error::UserError { .. })
            ));
        }
    }

    #[tokio::test]
    async fn go_back_to_integration() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        std::fs::write(repository.path().join("file.txt"), "one").unwrap();
        let oid_one = repository.commit_all("one");
        std::fs::write(repository.path().join("file.txt"), "two").unwrap();
        repository.commit_all("two");
        repository.push();

        println!("{}", repository.path().display());

        let base = controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert!(branches.is_empty());

        repository.checkout_commit(oid_one);

        let base_two = controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);

        assert_eq!(base_two, base);
    }
}

mod unapply {
    use super::*;

    #[tokio::test]
    async fn unapply_with_data() {
        let Test {
            project_id,
            controller,
            repository,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        std::fs::write(repository.path().join("file.txt"), "content").unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);

        controller
            .unapply_virtual_branch(&project_id, &branches[0].id)
            .await
            .unwrap();

        assert!(!repository.path().join("file.txt").exists());

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert!(!branches[0].active);
    }

    #[tokio::test]
    async fn conflicting() {
        let Test {
            project_id,
            controller,
            repository,
            ..
        } = Test::default();

        // make sure we have an undiscovered commit in the remote branch
        {
            fs::write(repository.path().join("file.txt"), "first").unwrap();
            let first_commit_oid = repository.commit_all("first");
            fs::write(repository.path().join("file.txt"), "second").unwrap();
            repository.commit_all("second");
            repository.push();
            repository.reset_hard(Some(first_commit_oid));
        }

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = {
            // make a conflicting branch, and stash it

            std::fs::write(repository.path().join("file.txt"), "conflict").unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert!(branches[0].base_current);
            assert!(branches[0].active);
            assert_eq!(branches[0].files[0].hunks[0].diff, "@@ -1,1 +1,1 @@\n-first\n\\ No newline at end of file\n+conflict\n\\ No newline at end of file\n");

            controller
                .unapply_virtual_branch(&project_id, &branches[0].id)
                .await
                .unwrap();

            branches[0].id
        };

        {
            // update base branch, causing conflict
            controller.update_base_branch(&project_id).await.unwrap();

            assert_eq!(
                std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "second"
            );

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|branch| branch.id == branch_id)
                .unwrap();
            assert!(!branch.base_current);
            assert!(!branch.active);
        }

        {
            // apply branch, it should conflict
            controller
                .apply_virtual_branch(&project_id, &branch_id)
                .await
                .unwrap();

            assert_eq!(
                std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "<<<<<<< ours\nconflict\n=======\nsecond\n>>>>>>> theirs\n"
            );

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert!(branch.base_current);
            assert!(branch.conflicted);
            assert_eq!(branch.files[0].hunks[0].diff, "@@ -1,1 +1,5 @@\n-first\n\\ No newline at end of file\n+<<<<<<< ours\n+conflict\n+=======\n+second\n+>>>>>>> theirs\n");
        }

        {
            controller
                .unapply_virtual_branch(&project_id, &branch_id)
                .await
                .unwrap();

            assert_eq!(
                std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "second"
            );

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert!(!branch.active);
            assert!(!branch.base_current);
            assert!(!branch.conflicted);
            assert_eq!(branch.files[0].hunks[0].diff, "@@ -1,1 +1,1 @@\n-first\n\\ No newline at end of file\n+conflict\n\\ No newline at end of file\n");
        }
    }

    #[tokio::test]
    async fn delete_if_empty() {
        let Test {
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);

        controller
            .unapply_virtual_branch(&project_id, &branches[0].id)
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 0);
    }
}

mod apply_virtual_branch {
    use super::*;

    #[tokio::test]
    async fn deltect_conflict() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch1_id = {
            let branch1_id = controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();
            fs::write(repository.path().join("file.txt"), "branch one").unwrap();

            branch1_id
        };

        // unapply first vbranch
        controller
            .unapply_virtual_branch(&project_id, &branch1_id)
            .await
            .unwrap();

        {
            // create another vbranch that conflicts with the first one
            controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();
            fs::write(repository.path().join("file.txt"), "branch two").unwrap();
        }

        {
            // it should not be possible to apply the first branch
            assert!(!controller
                .can_apply_virtual_branch(&project_id, &branch1_id)
                .await
                .unwrap());

            assert!(matches!(
                controller
                    .apply_virtual_branch(&project_id, &branch1_id)
                    .await,
                Err(ControllerError::Action(
                    errors::ApplyBranchError::BranchConflicts(_)
                ))
            ));
        }
    }

    #[tokio::test]
    async fn rebase_commit() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        // make sure we have an undiscovered commit in the remote branch
        {
            fs::write(repository.path().join("file.txt"), "one").unwrap();
            fs::write(repository.path().join("another_file.txt"), "").unwrap();
            let first_commit_oid = repository.commit_all("first");
            fs::write(repository.path().join("file.txt"), "two").unwrap();
            repository.commit_all("second");
            repository.push();
            repository.reset_hard(Some(first_commit_oid));
        }

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch1_id = {
            // create a branch with some commited work
            let branch1_id = controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();
            fs::write(repository.path().join("another_file.txt"), "virtual").unwrap();

            controller
                .create_commit(&project_id, &branch1_id, "virtual commit", None, false)
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert!(branches[0].active);
            assert_eq!(branches[0].files.len(), 0);
            assert_eq!(branches[0].commits.len(), 1);

            branch1_id
        };

        {
            // unapply first vbranch
            controller
                .unapply_virtual_branch(&project_id, &branch1_id)
                .await
                .unwrap();

            assert_eq!(
                fs::read_to_string(repository.path().join("another_file.txt")).unwrap(),
                ""
            );
            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "one"
            );

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].files.len(), 0);
            assert_eq!(branches[0].commits.len(), 1);
            assert!(!branches[0].active);
        }

        {
            // fetch remote
            controller.update_base_branch(&project_id).await.unwrap();

            // branch is stil unapplied
            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].files.len(), 0);
            assert_eq!(branches[0].commits.len(), 1);
            assert!(!branches[0].active);
            assert!(!branches[0].conflicted);

            assert_eq!(
                fs::read_to_string(repository.path().join("another_file.txt")).unwrap(),
                ""
            );
            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "two"
            );
        }

        {
            // apply first vbranch again
            controller
                .apply_virtual_branch(&project_id, &branch1_id)
                .await
                .unwrap();

            // it should be rebased
            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].files.len(), 0);
            assert_eq!(branches[0].commits.len(), 1);
            assert!(branches[0].active);
            assert!(!branches[0].conflicted);

            assert_eq!(
                fs::read_to_string(repository.path().join("another_file.txt")).unwrap(),
                "virtual"
            );

            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "two"
            );
        }
    }

    #[tokio::test]
    async fn rebase_work() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        // make sure we have an undiscovered commit in the remote branch
        {
            let first_commit_oid = repository.commit_all("first");
            fs::write(repository.path().join("file.txt"), "").unwrap();
            repository.commit_all("second");
            repository.push();
            repository.reset_hard(Some(first_commit_oid));
        }

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch1_id = {
            // make a branch with some work
            let branch1_id = controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();
            fs::write(repository.path().join("another_file.txt"), "").unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert!(branches[0].active);
            assert_eq!(branches[0].files.len(), 1);
            assert_eq!(branches[0].commits.len(), 0);

            branch1_id
        };

        {
            // unapply first vbranch
            controller
                .unapply_virtual_branch(&project_id, &branch1_id)
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].files.len(), 1);
            assert_eq!(branches[0].commits.len(), 0);
            assert!(!branches[0].active);

            assert!(!repository.path().join("another_file.txt").exists());
            assert!(!repository.path().join("file.txt").exists());
        }

        {
            // fetch remote
            controller.update_base_branch(&project_id).await.unwrap();

            // first branch is stil unapplied
            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].files.len(), 1);
            assert_eq!(branches[0].commits.len(), 0);
            assert!(!branches[0].active);
            assert!(!branches[0].conflicted);

            assert!(!repository.path().join("another_file.txt").exists());
            assert!(repository.path().join("file.txt").exists());
        }

        {
            // apply first vbranch again
            controller
                .apply_virtual_branch(&project_id, &branch1_id)
                .await
                .unwrap();

            // workdir should be rebased, and work should be restored
            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].files.len(), 1);
            assert_eq!(branches[0].commits.len(), 0);
            assert!(branches[0].active);
            assert!(!branches[0].conflicted);

            assert!(repository.path().join("another_file.txt").exists());
            assert!(repository.path().join("file.txt").exists());
        }
    }
}

#[tokio::test]
async fn resolve_conflict_flow() {
    let Test {
        repository,
        project_id,
        controller,
        ..
    } = Test::default();

    // make sure we have an undiscovered commit in the remote branch
    {
        fs::write(repository.path().join("file.txt"), "first").unwrap();
        let first_commit_oid = repository.commit_all("first");
        fs::write(repository.path().join("file.txt"), "second").unwrap();
        repository.commit_all("second");
        repository.push();
        repository.reset_hard(Some(first_commit_oid));
    }

    controller
        .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
        .await
        .unwrap();

    let branch1_id = {
        // make a branch that conflicts with the remote branch, but doesn't know about it yet
        let branch1_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();
        fs::write(repository.path().join("file.txt"), "conflict").unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert_eq!(branches[0].id, branch1_id);
        assert!(branches[0].active);

        branch1_id
    };

    {
        // fetch remote
        controller.update_base_branch(&project_id).await.unwrap();

        // there is a conflict now, so the branch should be inactive
        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert_eq!(branches[0].id, branch1_id);
        assert!(!branches[0].active);
    }

    {
        // when we apply conflicted branch, it has conflict
        controller
            .apply_virtual_branch(&project_id, &branch1_id)
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert_eq!(branches[0].id, branch1_id);
        assert!(branches[0].active);
        assert!(branches[0].conflicted);

        // and the conflict markers are in the file
        assert_eq!(
            fs::read_to_string(repository.path().join("file.txt")).unwrap(),
            "<<<<<<< ours\nconflict\n=======\nsecond\n>>>>>>> theirs\n"
        );
    }

    {
        // can't commit conflicts
        assert!(matches!(
            controller
                .create_commit(&project_id, &branch1_id, "commit conflicts", None, false)
                .await,
            Err(ControllerError::Action(errors::CommitError::Conflicted(_)))
        ));
    }

    {
        // fixing the conflict removes conflicted mark
        fs::write(repository.path().join("file.txt"), "resolved").unwrap();
        let commit_oid = controller
            .create_commit(&project_id, &branch1_id, "resolution", None, false)
            .await
            .unwrap();

        let commit = repository.find_commit(commit_oid).unwrap();
        assert_eq!(commit.parent_count(), 2);

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert_eq!(branches[0].id, branch1_id);
        assert!(branches[0].active);
        assert!(!branches[0].conflicted);
    }
}

mod fetch_from_target {
    use super::*;

    #[tokio::test]
    async fn should_update_last_fetched() {
        let Test {
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let before_fetch = controller.get_base_branch_data(&project_id).await.unwrap();
        assert!(before_fetch.unwrap().last_fetched_ms.is_none());

        let fetch = controller.fetch_from_target(&project_id).await.unwrap();
        assert!(fetch.last_fetched_ms.is_some());

        let after_fetch = controller.get_base_branch_data(&project_id).await.unwrap();
        assert!(after_fetch.as_ref().unwrap().last_fetched_ms.is_some());
        assert_eq!(fetch.last_fetched_ms, after_fetch.unwrap().last_fetched_ms);

        let second_fetch = controller.fetch_from_target(&project_id).await.unwrap();
        assert!(second_fetch.last_fetched_ms.is_some());
        assert_ne!(fetch.last_fetched_ms, second_fetch.last_fetched_ms);

        let after_second_fetch = controller.get_base_branch_data(&project_id).await.unwrap();
        assert!(after_second_fetch
            .as_ref()
            .unwrap()
            .last_fetched_ms
            .is_some());
        assert_eq!(
            second_fetch.last_fetched_ms,
            after_second_fetch.unwrap().last_fetched_ms
        );
    }
}

mod update_base_branch {
    use super::*;

    mod unapplied_branch {
        use super::*;

        #[tokio::test]
        async fn conflicts_with_uncommitted_work() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch that is unapplied and contains not commited conflict
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "conflict").unwrap();
                controller
                    .unapply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();

                branch_id
            };

            {
                // when fetching remote
                controller.update_base_branch(&project_id).await.unwrap();

                // branch should not be changed.

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(!branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 0);
                assert!(!controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap());
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 0);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "<<<<<<< ours\nconflict\n=======\nsecond\n>>>>>>> theirs\n"
                );
            }
        }

        #[tokio::test]
        async fn commited_conflict_not_pushed() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch with a commit that conflicts with upstream, and work that fixes
                // that conflict
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "conflict").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "conflicting commit", None, false)
                    .await
                    .unwrap();

                controller
                    .unapply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();

                branch_id
            };

            {
                // when fetching remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should not change the branch.

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(!branches[0].base_current);
                assert_eq!(branches[0].files.len(), 0);
                assert_eq!(branches[0].commits.len(), 1);
                assert!(!controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap());
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "<<<<<<< ours\nconflict\n=======\nsecond\n>>>>>>> theirs\n"
                );
            }
        }

        #[tokio::test]
        async fn commited_conflict_pushed() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch with a commit that conflicts with upstream, and work that fixes
                // that conflict
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "conflict").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "conflicting commit", None, false)
                    .await
                    .unwrap();

                controller
                    .push_virtual_branch(&project_id, &branch_id, false)
                    .await
                    .unwrap();

                controller
                    .unapply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();

                branch_id
            };

            {
                // when fetching remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should not change the branch.

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(!branches[0].base_current);
                assert_eq!(branches[0].files.len(), 0);
                assert_eq!(branches[0].commits.len(), 1);
                assert!(!controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap());
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "<<<<<<< ours\nconflict\n=======\nsecond\n>>>>>>> theirs\n"
                );
            }
        }

        #[tokio::test]
        async fn commited_conflict_not_pushed_fixed_with_more_work() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch with a commit that conflicts with upstream, and work that fixes
                // that conflict
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "conflict").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "conflicting commit", None, false)
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "fix conflict").unwrap();

                controller
                    .unapply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();

                branch_id
            };

            {
                // when fetching remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should rebase upstream, and leave uncommited file as is

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(!branches[0].base_current); // TODO: should be true
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert!(!controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap()); // TODO: should be true
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "<<<<<<< ours\nfix conflict\n=======\nsecond\n>>>>>>> theirs\n"
                );
            }
        }

        #[tokio::test]
        async fn commited_conflict_pushed_fixed_with_more_work() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch with a commit that conflicts with upstream, and work that fixes
                // that conflict
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "conflict").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "conflicting commit", None, false)
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "fix conflict").unwrap();

                controller
                    .unapply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();

                branch_id
            };

            {
                // when fetching remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should not touch the branch

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(!branches[0].base_current);
                assert_eq!(branches[0].commits.len(), 1);
                assert_eq!(branches[0].files.len(), 1);
                assert!(!controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap());
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "<<<<<<< ours\nfix conflict\n=======\nsecond\n>>>>>>> theirs\n"
                );
            }
        }

        #[tokio::test]
        async fn no_conflicts() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch that conflicts with the remote branch, but doesn't know about it yet
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file2.txt"), "no conflict").unwrap();

                controller
                    .create_commit(
                        &project_id,
                        &branch_id,
                        "non conflicting commit",
                        None,
                        false,
                    )
                    .await
                    .unwrap();

                fs::write(repository.path().join("file2.txt"), "still no conflicts").unwrap();

                controller
                    .unapply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();

                branch_id
            };

            {
                // fetching remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should update branch base

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert!(branches[0].upstream.is_none());
                assert!(controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap());
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(!branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "second"
                );
            }
        }

        #[tokio::test]
        async fn integrated_commit_plus_work() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                repository.commit_all("first");
                repository.push();
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch that conflicts with the remote branch, but doesn't know about it yet
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "second").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "second", None, false)
                    .await
                    .unwrap();

                // more local work in the same branch
                fs::write(repository.path().join("file2.txt"), "other").unwrap();

                controller
                    .push_virtual_branch(&project_id, &branch_id, false)
                    .await
                    .unwrap();

                {
                    // merge branch upstream
                    let branch = controller
                        .list_virtual_branches(&project_id)
                        .await
                        .unwrap()
                        .into_iter()
                        .find(|b| b.id == branch_id)
                        .unwrap();

                    repository.merge(&branch.upstream.as_ref().unwrap().name);
                    repository.fetch();
                }

                controller
                    .unapply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                branch_id
            };

            {
                // fetch remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should remove integrated commit, but leave work

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 0);
                assert!(branches[0].upstream.is_none());
                assert!(controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap());
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(!branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 0);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "second"
                );
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file2.txt")).unwrap(),
                    "other"
                );
            }
        }

        #[tokio::test]
        async fn all_integrated() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            {
                // make a branch that conflicts with the remote branch, but doesn't know about it yet
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "second").unwrap();

                controller
                    .create_commit(&project_id, &branch_id, "second", None, false)
                    .await
                    .unwrap();

                controller
                    .unapply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
            };

            {
                // fetch remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should remove identical branch

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 0);
            }
        }

        #[tokio::test]
        async fn integrate_work_while_being_behind() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();

            {
                // open pr
                fs::write(repository.path().join("file2.txt"), "new file").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "second", None, false)
                    .await
                    .unwrap();
                controller
                    .push_virtual_branch(&project_id, &branch_id, false)
                    .await
                    .unwrap();
            }

            controller
                .unapply_virtual_branch(&project_id, &branch_id)
                .await
                .unwrap();

            {
                // merge pr
                let branch =
                    controller.list_virtual_branches(&project_id).await.unwrap()[0].clone();
                repository.merge(&branch.upstream.as_ref().unwrap().name);
                repository.fetch();
            }

            {
                // fetch remote
                controller.update_base_branch(&project_id).await.unwrap();

                // just removes integrated branch
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 0);
            }
        }
    }

    mod applied_branch {
        use super::*;

        #[tokio::test]
        async fn conflicts_with_uncommitted_work() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch that conflicts with the remote branch, but doesn't know about it yet
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "conflict").unwrap();

                branch_id
            };

            {
                // fetch remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should stash conflicing branch

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(!branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 0);
                assert!(!controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap());
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 0);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "<<<<<<< ours\nconflict\n=======\nsecond\n>>>>>>> theirs\n"
                );
            }
        }

        #[tokio::test]
        async fn commited_conflict_not_pushed() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch with a commit that conflicts with upstream, and work that fixes
                // that conflict
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "conflict").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "conflicting commit", None, false)
                    .await
                    .unwrap();

                branch_id
            };

            {
                // when fetching remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should stash the branch.

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(!branches[0].base_current);
                assert_eq!(branches[0].files.len(), 0);
                assert_eq!(branches[0].commits.len(), 1);
                assert!(!controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap());
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "<<<<<<< ours\nconflict\n=======\nsecond\n>>>>>>> theirs\n"
                );
            }
        }

        #[tokio::test]
        async fn commited_conflict_pushed() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch with a commit that conflicts with upstream, and work that fixes
                // that conflict
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "conflict").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "conflicting commit", None, false)
                    .await
                    .unwrap();

                controller
                    .push_virtual_branch(&project_id, &branch_id, false)
                    .await
                    .unwrap();

                branch_id
            };

            {
                // when fetching remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should stash the branch.

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(!branches[0].base_current);
                assert_eq!(branches[0].files.len(), 0);
                assert_eq!(branches[0].commits.len(), 1);
                assert!(!controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap());
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "<<<<<<< ours\nconflict\n=======\nsecond\n>>>>>>> theirs\n"
                );
            }
        }

        #[tokio::test]
        async fn commited_conflict_not_pushed_fixed_with_more_work() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch with a commit that conflicts with upstream, and work that fixes
                // that conflict
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "conflict").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "conflicting commit", None, false)
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "fix conflict").unwrap();

                branch_id
            };

            {
                // when fetching remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should rebase upstream, and leave uncommited file as is

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(!branches[0].base_current); // TODO: should be true
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert!(!controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap()); // TODO: should be true
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "<<<<<<< ours\nfix conflict\n=======\nsecond\n>>>>>>> theirs\n"
                );
            }
        }

        #[tokio::test]
        async fn commited_conflict_pushed_fixed_with_more_work() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch with a commit that conflicts with upstream, and work that fixes
                // that conflict
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "conflict").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "conflicting commit", None, false)
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "fix conflict").unwrap();

                branch_id
            };

            {
                // when fetching remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should merge upstream, and leave uncommited file as is.

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(!branches[0].base_current); // TODO: should be true
                assert_eq!(branches[0].commits.len(), 1); // TODO: should be 2
                assert_eq!(branches[0].files.len(), 1);
                assert!(!controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap()); // TODO: should be true
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "<<<<<<< ours\nfix conflict\n=======\nsecond\n>>>>>>> theirs\n"
                );
            }
        }

        mod no_conflicts_pushed {
            use super::*;

            #[tokio::test]
            async fn force_push_ok() {
                let Test {
                    repository,
                    project_id,
                    controller,
                    projects,
                    ..
                } = Test::default();

                // make sure we have an undiscovered commit in the remote branch
                {
                    fs::write(repository.path().join("file.txt"), "first").unwrap();
                    let first_commit_oid = repository.commit_all("first");
                    fs::write(repository.path().join("file.txt"), "second").unwrap();
                    repository.commit_all("second");
                    repository.push();
                    repository.reset_hard(Some(first_commit_oid));
                }

                projects
                    .update(&projects::UpdateRequest {
                        id: project_id,
                        ok_with_force_push: Some(true),
                        ..Default::default()
                    })
                    .await
                    .unwrap();

                controller
                    .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                    .await
                    .unwrap();

                let branch_id = {
                    let branch_id = controller
                        .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                        .await
                        .unwrap();

                    fs::write(repository.path().join("file2.txt"), "no conflict").unwrap();

                    controller
                        .create_commit(&project_id, &branch_id, "no conflicts", None, false)
                        .await
                        .unwrap();
                    controller
                        .push_virtual_branch(&project_id, &branch_id, false)
                        .await
                        .unwrap();

                    fs::write(repository.path().join("file2.txt"), "still no conflict").unwrap();

                    branch_id
                };

                {
                    // fetch remote
                    controller.update_base_branch(&project_id).await.unwrap();

                    // rebases branch, since the branch is pushed and force pushing is
                    // allowed

                    let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                    assert_eq!(branches.len(), 1);
                    assert_eq!(branches[0].id, branch_id);
                    assert!(branches[0].active);
                    assert!(branches[0].requires_force);
                    assert!(branches[0].base_current);
                    assert_eq!(branches[0].files.len(), 1);
                    assert_eq!(branches[0].commits.len(), 1);
                    assert!(!branches[0].commits[0].is_remote);
                    assert!(!branches[0].commits[0].is_integrated);
                    assert!(controller
                        .can_apply_virtual_branch(&project_id, &branch_id)
                        .await
                        .unwrap());
                }
            }

            #[tokio::test]
            async fn force_push_not_ok() {
                let Test {
                    repository,
                    project_id,
                    controller,
                    projects,
                    ..
                } = Test::default();

                // make sure we have an undiscovered commit in the remote branch
                {
                    fs::write(repository.path().join("file.txt"), "first").unwrap();
                    let first_commit_oid = repository.commit_all("first");
                    fs::write(repository.path().join("file.txt"), "second").unwrap();
                    repository.commit_all("second");
                    repository.push();
                    repository.reset_hard(Some(first_commit_oid));
                }

                controller
                    .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                    .await
                    .unwrap();

                let branch_id = {
                    let branch_id = controller
                        .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                        .await
                        .unwrap();

                    fs::write(repository.path().join("file2.txt"), "no conflict").unwrap();

                    controller
                        .create_commit(&project_id, &branch_id, "no conflicts", None, false)
                        .await
                        .unwrap();
                    controller
                        .push_virtual_branch(&project_id, &branch_id, false)
                        .await
                        .unwrap();

                    fs::write(repository.path().join("file2.txt"), "still no conflict").unwrap();

                    branch_id
                };

                projects
                    .update(&projects::UpdateRequest {
                        id: project_id,
                        ok_with_force_push: Some(false),
                        ..Default::default()
                    })
                    .await
                    .unwrap();

                {
                    // fetch remote
                    controller.update_base_branch(&project_id).await.unwrap();

                    // creates a merge commit, since the branch is pushed

                    let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                    assert_eq!(branches.len(), 1);
                    assert_eq!(branches[0].id, branch_id);
                    assert!(branches[0].active);
                    assert!(!branches[0].requires_force);
                    assert!(branches[0].base_current);
                    assert_eq!(branches[0].files.len(), 1);
                    assert_eq!(branches[0].commits.len(), 2);
                    assert!(!branches[0].commits[0].is_remote);
                    assert!(!branches[0].commits[0].is_integrated);
                    assert!(branches[0].commits[1].is_remote);
                    assert!(!branches[0].commits[1].is_integrated);
                    assert!(controller
                        .can_apply_virtual_branch(&project_id, &branch_id)
                        .await
                        .unwrap());
                }
            }
        }

        #[tokio::test]
        async fn no_conflicts() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file2.txt"), "no conflict").unwrap();

                controller
                    .create_commit(&project_id, &branch_id, "no conflicts", None, false)
                    .await
                    .unwrap();

                fs::write(repository.path().join("file2.txt"), "still no conflict").unwrap();

                branch_id
            };

            {
                // fetch remote
                controller.update_base_branch(&project_id).await.unwrap();

                // just rebases branch

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert!(controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap());
            }

            {
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(!branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 1);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "second"
                );
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file2.txt")).unwrap(),
                    "still no conflict"
                );
            }
        }

        #[tokio::test]
        async fn integrated_commit_plus_work() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                repository.commit_all("first");
                repository.push();
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch that conflicts with the remote branch, but doesn't know about it yet
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "second").unwrap();

                controller
                    .create_commit(&project_id, &branch_id, "second", None, false)
                    .await
                    .unwrap();
                controller
                    .push_virtual_branch(&project_id, &branch_id, false)
                    .await
                    .unwrap();

                {
                    // merge branch upstream
                    let branch = controller
                        .list_virtual_branches(&project_id)
                        .await
                        .unwrap()
                        .into_iter()
                        .find(|b| b.id == branch_id)
                        .unwrap();
                    repository.merge(&branch.upstream.as_ref().unwrap().name);
                    repository.fetch();
                }

                // more local work in the same branch
                fs::write(repository.path().join("file2.txt"), "other").unwrap();

                branch_id
            };

            {
                // fetch remote
                controller.update_base_branch(&project_id).await.unwrap();

                // should remove integrated commit, but leave non integrated work as is

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 0);
                assert!(controller
                    .can_apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap());
            }

            {
                // applying the branch should produce conflict markers
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(!branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 0);
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                    "second"
                );
                assert_eq!(
                    std::fs::read_to_string(repository.path().join("file2.txt")).unwrap(),
                    "other"
                );
            }
        }

        #[tokio::test]
        async fn integrated_with_locked_conflicting_hunks() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(
                    repository.path().join("file.txt"),
                    "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n",
                )
                .unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(
                    repository.path().join("file.txt"),
                    "1\n2\n3\n4\n5\n6\n17\n8\n9\n10\n11\n12\n",
                )
                .unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            // branch has no conflict
            let branch_id = {
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(
                    repository.path().join("file.txt"),
                    "1\n2\n3\n4\n5\n6\n7\n8\n19\n10\n11\n12\n",
                )
                .unwrap();

                controller
                    .create_commit(&project_id, &branch_id, "first", None, false)
                    .await
                    .unwrap();

                branch_id
            };

            // push the branch
            controller
                .push_virtual_branch(&project_id, &branch_id, false)
                .await
                .unwrap();

            // another locked conflicing hunk
            fs::write(
                repository.path().join("file.txt"),
                "1\n2\n3\n4\n5\n6\n77\n8\n19\n10\n11\n12\n",
            )
            .unwrap();

            {
                // merge branch remotely
                let branch =
                    controller.list_virtual_branches(&project_id).await.unwrap()[0].clone();
                repository.merge(&branch.upstream.as_ref().unwrap().name);
            }

            repository.fetch();

            {
                controller.update_base_branch(&project_id).await.unwrap();

                // removes integrated commit, leaves non commited work as is

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(!branches[0].active);
                assert!(branches[0].commits.is_empty());
                assert!(!branches[0].files.is_empty());
            }

            {
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert!(branches[0].active);
                assert!(branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].files[0].hunks.len(), 1);
                assert_eq!(branches[0].files[0].hunks[0].diff, "@@ -4,7 +4,11 @@\n 4\n 5\n 6\n-7\n+<<<<<<< ours\n+77\n+=======\n+17\n+>>>>>>> theirs\n 8\n 19\n 10\n");
                assert_eq!(branches[0].commits.len(), 0);
            }
        }

        #[tokio::test]
        async fn integrated_with_locked_hunks() {
            let Test {
                repository,
                project_id,
                controller,
                projects,
                ..
            } = Test::default();

            projects
                .update(&projects::UpdateRequest {
                    id: project_id,
                    ok_with_force_push: Some(false),
                    ..Default::default()
                })
                .await
                .unwrap();

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "first").unwrap();

                controller
                    .create_commit(&project_id, &branch_id, "first", None, false)
                    .await
                    .unwrap();

                branch_id
            };

            controller
                .push_virtual_branch(&project_id, &branch_id, false)
                .await
                .unwrap();

            // another non-locked hunk
            fs::write(repository.path().join("file.txt"), "first\nsecond").unwrap();

            {
                // push and merge branch remotely
                let branch =
                    controller.list_virtual_branches(&project_id).await.unwrap()[0].clone();
                repository.merge(&branch.upstream.as_ref().unwrap().name);
            }

            repository.fetch();

            {
                controller.update_base_branch(&project_id).await.unwrap();

                // removes integrated commit, leaves non commited work as is

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].commits.is_empty());
                assert!(branches[0].upstream.is_none());
                assert_eq!(branches[0].files.len(), 1);
            }

            {
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert!(branches[0].active);
                assert!(!branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 0); // no merge commit
            }
        }

        #[tokio::test]
        async fn integrated_with_non_locked_hunks() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = {
                // make a branch that conflicts with the remote branch, but doesn't know about it yet
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "first").unwrap();

                controller
                    .create_commit(&project_id, &branch_id, "first", None, false)
                    .await
                    .unwrap();

                branch_id
            };

            controller
                .push_virtual_branch(&project_id, &branch_id, false)
                .await
                .unwrap();

            // another non-locked hunk
            fs::write(repository.path().join("another_file.txt"), "first").unwrap();

            {
                // push and merge branch remotely
                let branch =
                    controller.list_virtual_branches(&project_id).await.unwrap()[0].clone();
                repository.merge(&branch.upstream.as_ref().unwrap().name);
            }

            repository.fetch();

            {
                controller.update_base_branch(&project_id).await.unwrap();

                // removes integrated commit, leaves non commited work as is

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].commits.is_empty());
                assert!(branches[0].upstream.is_none());
                assert!(!branches[0].files.is_empty());
            }

            {
                controller
                    .apply_virtual_branch(&project_id, &branch_id)
                    .await
                    .unwrap();

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert!(branches[0].active);
                assert!(!branches[0].conflicted);
                assert!(branches[0].base_current);
                assert_eq!(branches[0].files.len(), 1);
                assert_eq!(branches[0].commits.len(), 0);
            }
        }

        #[tokio::test]
        async fn all_integrated() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            {
                // make a branch that conflicts with the remote branch, but doesn't know about it yet
                let branch_id = controller
                    .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                    .await
                    .unwrap();

                fs::write(repository.path().join("file.txt"), "second").unwrap();

                controller
                    .create_commit(&project_id, &branch_id, "second", None, false)
                    .await
                    .unwrap();
            };

            {
                // fetch remote
                controller.update_base_branch(&project_id).await.unwrap();

                // just removes integrated branch

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 0);
            }
        }

        #[tokio::test]
        async fn integrate_work_while_being_behind() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            // make sure we have an undiscovered commit in the remote branch
            {
                fs::write(repository.path().join("file.txt"), "first").unwrap();
                let first_commit_oid = repository.commit_all("first");
                fs::write(repository.path().join("file.txt"), "second").unwrap();
                repository.commit_all("second");
                repository.push();
                repository.reset_hard(Some(first_commit_oid));
            }

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();

            {
                // open pr
                fs::write(repository.path().join("file2.txt"), "new file").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "second", None, false)
                    .await
                    .unwrap();
                controller
                    .push_virtual_branch(&project_id, &branch_id, false)
                    .await
                    .unwrap();
            }

            {
                // merge pr
                let branch =
                    controller.list_virtual_branches(&project_id).await.unwrap()[0].clone();
                repository.merge(&branch.upstream.as_ref().unwrap().name);
                repository.fetch();
            }

            {
                // fetch remote
                controller.update_base_branch(&project_id).await.unwrap();

                // just removes integrated branch
                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 0);
            }
        }
    }
}

mod reset_virtual_branch {
    use gblib::virtual_branches::{controller::ControllerError, errors::ResetBranchError};

    use super::*;

    #[tokio::test]
    async fn to_head() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch1_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        let oid = {
            fs::write(repository.path().join("file.txt"), "content").unwrap();

            // commit changes
            let oid = controller
                .create_commit(&project_id, &branch1_id, "commit", None, false)
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].commits.len(), 1);
            assert_eq!(branches[0].commits[0].id, oid);
            assert_eq!(branches[0].files.len(), 0);
            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "content"
            );

            oid
        };

        {
            // reset changes to head
            controller
                .reset_virtual_branch(&project_id, &branch1_id, oid)
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].commits.len(), 1);
            assert_eq!(branches[0].commits[0].id, oid);
            assert_eq!(branches[0].files.len(), 0);
            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "content"
            );
        }
    }

    #[tokio::test]
    async fn to_target() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        let base_branch = controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch1_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            fs::write(repository.path().join("file.txt"), "content").unwrap();

            // commit changes
            let oid = controller
                .create_commit(&project_id, &branch1_id, "commit", None, false)
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].commits.len(), 1);
            assert_eq!(branches[0].commits[0].id, oid);
            assert_eq!(branches[0].files.len(), 0);
            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "content"
            );
        }

        {
            // reset changes to head
            controller
                .reset_virtual_branch(&project_id, &branch1_id, base_branch.base_sha)
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].commits.len(), 0);
            assert_eq!(branches[0].files.len(), 1);
            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "content"
            );
        }
    }

    #[tokio::test]
    async fn to_commit() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch1_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        let first_commit_oid = {
            // commit some changes

            fs::write(repository.path().join("file.txt"), "content").unwrap();

            let oid = controller
                .create_commit(&project_id, &branch1_id, "commit", None, false)
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].commits.len(), 1);
            assert_eq!(branches[0].commits[0].id, oid);
            assert_eq!(branches[0].files.len(), 0);
            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "content"
            );

            oid
        };

        {
            // commit some more
            fs::write(repository.path().join("file.txt"), "more content").unwrap();

            let second_commit_oid = controller
                .create_commit(&project_id, &branch1_id, "commit", None, false)
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].commits.len(), 2);
            assert_eq!(branches[0].commits[0].id, second_commit_oid);
            assert_eq!(branches[0].commits[1].id, first_commit_oid);
            assert_eq!(branches[0].files.len(), 0);
            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "more content"
            );
        }

        {
            // reset changes to the first commit
            controller
                .reset_virtual_branch(&project_id, &branch1_id, first_commit_oid)
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].commits.len(), 1);
            assert_eq!(branches[0].commits[0].id, first_commit_oid);
            assert_eq!(branches[0].files.len(), 1);
            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "more content"
            );
        }
    }

    #[tokio::test]
    async fn to_non_existing() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch1_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            fs::write(repository.path().join("file.txt"), "content").unwrap();

            // commit changes
            let oid = controller
                .create_commit(&project_id, &branch1_id, "commit", None, false)
                .await
                .unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].commits.len(), 1);
            assert_eq!(branches[0].commits[0].id, oid);
            assert_eq!(branches[0].files.len(), 0);
            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "content"
            );

            oid
        };

        assert!(matches!(
            controller
                .reset_virtual_branch(
                    &project_id,
                    &branch1_id,
                    "fe14df8c66b73c6276f7bb26102ad91da680afcb".parse().unwrap()
                )
                .await,
            Err(ControllerError::Action(
                ResetBranchError::CommitNotFoundInBranch(_)
            ))
        ));
    }
}

mod upstream {
    use super::*;

    #[tokio::test]
    async fn detect_upstream_commits() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch1_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        let oid1 = {
            // create first commit
            fs::write(repository.path().join("file.txt"), "content").unwrap();
            controller
                .create_commit(&project_id, &branch1_id, "commit", None, false)
                .await
                .unwrap()
        };

        let oid2 = {
            // create second commit
            fs::write(repository.path().join("file.txt"), "content2").unwrap();
            controller
                .create_commit(&project_id, &branch1_id, "commit", None, false)
                .await
                .unwrap()
        };

        // push
        controller
            .push_virtual_branch(&project_id, &branch1_id, false)
            .await
            .unwrap();

        let oid3 = {
            // create third commit
            fs::write(repository.path().join("file.txt"), "content3").unwrap();
            controller
                .create_commit(&project_id, &branch1_id, "commit", None, false)
                .await
                .unwrap()
        };

        {
            // should correctly detect pushed commits
            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].commits.len(), 3);
            assert_eq!(branches[0].commits[0].id, oid3);
            assert!(!branches[0].commits[0].is_remote);
            assert_eq!(branches[0].commits[1].id, oid2);
            assert!(branches[0].commits[1].is_remote);
            assert_eq!(branches[0].commits[2].id, oid1);
            assert!(branches[0].commits[2].is_remote);
        }
    }

    #[tokio::test]
    async fn detect_integrated_commits() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch1_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        let oid1 = {
            // create first commit
            fs::write(repository.path().join("file.txt"), "content").unwrap();
            controller
                .create_commit(&project_id, &branch1_id, "commit", None, false)
                .await
                .unwrap()
        };

        let oid2 = {
            // create second commit
            fs::write(repository.path().join("file.txt"), "content2").unwrap();
            controller
                .create_commit(&project_id, &branch1_id, "commit", None, false)
                .await
                .unwrap()
        };

        // push
        controller
            .push_virtual_branch(&project_id, &branch1_id, false)
            .await
            .unwrap();

        {
            // merge branch upstream
            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch1_id)
                .unwrap();
            repository.merge(&branch.upstream.as_ref().unwrap().name);
            repository.fetch();
        }

        let oid3 = {
            // create third commit
            fs::write(repository.path().join("file.txt"), "content3").unwrap();
            controller
                .create_commit(&project_id, &branch1_id, "commit", None, false)
                .await
                .unwrap()
        };

        {
            // should correctly detect pushed commits
            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch1_id);
            assert_eq!(branches[0].commits.len(), 3);
            assert_eq!(branches[0].commits[0].id, oid3);
            assert!(!branches[0].commits[0].is_integrated);
            assert_eq!(branches[0].commits[1].id, oid2);
            assert!(branches[0].commits[1].is_integrated);
            assert_eq!(branches[0].commits[2].id, oid1);
            assert!(branches[0].commits[2].is_integrated);
        }
    }
}

mod cherry_pick {
    use super::*;

    mod cleanly {
        use super::*;

        #[tokio::test]
        async fn applied() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();

            let commit_one = {
                fs::write(repository.path().join("file.txt"), "content").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "commit", None, false)
                    .await
                    .unwrap()
            };

            let commit_two = {
                fs::write(repository.path().join("file.txt"), "content two").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "commit", None, false)
                    .await
                    .unwrap()
            };

            controller
                .push_virtual_branch(&project_id, &branch_id, false)
                .await
                .unwrap();

            controller
                .reset_virtual_branch(&project_id, &branch_id, commit_one)
                .await
                .unwrap();

            repository.reset_hard(None);

            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "content"
            );

            let cherry_picked_commit_oid = controller
                .cherry_pick(&project_id, &branch_id, commit_two)
                .await
                .unwrap();
            assert!(cherry_picked_commit_oid.is_some());
            assert!(repository.path().join("file.txt").exists());
            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "content two"
            );

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
            assert_eq!(branches[0].id, branch_id);
            assert!(branches[0].active);
            assert_eq!(branches[0].commits.len(), 2);
            assert_eq!(branches[0].commits[0].id, cherry_picked_commit_oid.unwrap());
            assert_eq!(branches[0].commits[1].id, commit_one);
        }

        #[tokio::test]
        async fn to_different_branch() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();

            let commit_one = {
                fs::write(repository.path().join("file.txt"), "content").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "commit", None, false)
                    .await
                    .unwrap()
            };

            let commit_two = {
                fs::write(repository.path().join("file_two.txt"), "content two").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "commit", None, false)
                    .await
                    .unwrap()
            };

            controller
                .push_virtual_branch(&project_id, &branch_id, false)
                .await
                .unwrap();

            controller
                .reset_virtual_branch(&project_id, &branch_id, commit_one)
                .await
                .unwrap();

            repository.reset_hard(None);

            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "content"
            );
            assert!(!repository.path().join("file_two.txt").exists());

            let branch_two_id = controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();

            let cherry_picked_commit_oid = controller
                .cherry_pick(&project_id, &branch_two_id, commit_two)
                .await
                .unwrap();
            assert!(cherry_picked_commit_oid.is_some());

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert!(repository.path().join("file_two.txt").exists());
            assert_eq!(
                fs::read_to_string(repository.path().join("file_two.txt")).unwrap(),
                "content two"
            );

            assert_eq!(branches.len(), 2);
            assert_eq!(branches[0].id, branch_id);
            assert!(!branches[0].active);
            assert_eq!(branches[0].commits.len(), 1);
            assert_eq!(branches[0].commits[0].id, commit_one);

            assert_eq!(branches[1].id, branch_two_id);
            assert!(branches[1].active);
            assert_eq!(branches[1].commits.len(), 1);
            assert_eq!(branches[1].commits[0].id, cherry_picked_commit_oid.unwrap());
        }

        #[tokio::test]
        async fn non_applied() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();

            let commit_one_oid = {
                fs::write(repository.path().join("file.txt"), "content").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "commit", None, false)
                    .await
                    .unwrap()
            };

            {
                fs::write(repository.path().join("file_two.txt"), "content two").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "commit", None, false)
                    .await
                    .unwrap()
            };

            let commit_three_oid = {
                fs::write(repository.path().join("file_three.txt"), "content three").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "commit", None, false)
                    .await
                    .unwrap()
            };

            controller
                .reset_virtual_branch(&project_id, &branch_id, commit_one_oid)
                .await
                .unwrap();

            controller
                .unapply_virtual_branch(&project_id, &branch_id)
                .await
                .unwrap();

            assert!(matches!(
                controller
                    .cherry_pick(&project_id, &branch_id, commit_three_oid)
                    .await,
                Err(ControllerError::Action(errors::CherryPickError::NotApplied))
            ));
        }
    }

    mod with_conflicts {
        use super::*;

        #[tokio::test]
        async fn applied() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();

            let commit_one = {
                fs::write(repository.path().join("file.txt"), "content").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "commit one", None, false)
                    .await
                    .unwrap()
            };

            {
                fs::write(repository.path().join("file_two.txt"), "content two").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "commit two", None, false)
                    .await
                    .unwrap()
            };

            let commit_three = {
                fs::write(repository.path().join("file_three.txt"), "content three").unwrap();
                controller
                    .create_commit(&project_id, &branch_id, "commit three", None, false)
                    .await
                    .unwrap()
            };

            controller
                .push_virtual_branch(&project_id, &branch_id, false)
                .await
                .unwrap();

            controller
                .reset_virtual_branch(&project_id, &branch_id, commit_one)
                .await
                .unwrap();

            repository.reset_hard(None);
            assert_eq!(
                fs::read_to_string(repository.path().join("file.txt")).unwrap(),
                "content"
            );
            assert!(!repository.path().join("file_two.txt").exists());
            assert!(!repository.path().join("file_three.txt").exists());

            // introduce conflict with the remote commit
            fs::write(repository.path().join("file_three.txt"), "conflict").unwrap();

            {
                // cherry picking leads to conflict
                let cherry_picked_commit_oid = controller
                    .cherry_pick(&project_id, &branch_id, commit_three)
                    .await
                    .unwrap();
                assert!(cherry_picked_commit_oid.is_none());

                assert_eq!(
                    fs::read_to_string(repository.path().join("file_three.txt")).unwrap(),
                    "<<<<<<< ours\nconflict\n=======\ncontent three\n>>>>>>> theirs\n"
                );

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].conflicted);
                assert_eq!(branches[0].files.len(), 1);
                assert!(branches[0].files[0].conflicted);
                assert_eq!(branches[0].commits.len(), 1);
            }

            {
                // conflict can be resolved
                fs::write(repository.path().join("file_three.txt"), "resolved").unwrap();
                let commited_oid = controller
                    .create_commit(&project_id, &branch_id, "resolution", None, false)
                    .await
                    .unwrap();

                let commit = repository.find_commit(commited_oid).unwrap();
                assert_eq!(commit.parent_count(), 2);

                let branches = controller.list_virtual_branches(&project_id).await.unwrap();
                assert_eq!(branches.len(), 1);
                assert_eq!(branches[0].id, branch_id);
                assert!(branches[0].active);
                assert!(branches[0].requires_force);
                assert!(!branches[0].conflicted);
                assert_eq!(branches[0].commits.len(), 2);
                // resolution commit is there
                assert_eq!(branches[0].commits[0].id, commited_oid);
                assert_eq!(branches[0].commits[1].id, commit_one);
            }
        }

        #[tokio::test]
        async fn non_applied() {
            let Test {
                repository,
                project_id,
                controller,
                ..
            } = Test::default();

            let commit_oid = {
                let first = repository.commit_all("commit");
                fs::write(repository.path().join("file.txt"), "content").unwrap();
                let second = repository.commit_all("commit");
                repository.push();
                repository.reset_hard(Some(first));
                second
            };

            controller
                .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            let branch_id = controller
                .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
                .await
                .unwrap();

            // introduce conflict with the remote commit
            fs::write(repository.path().join("file.txt"), "conflict").unwrap();

            controller
                .unapply_virtual_branch(&project_id, &branch_id)
                .await
                .unwrap();

            assert!(matches!(
                controller
                    .cherry_pick(&project_id, &branch_id, commit_oid)
                    .await,
                Err(ControllerError::Action(errors::CherryPickError::NotApplied))
            ));
        }
    }
}

mod amend {
    use super::*;

    #[tokio::test]
    async fn to_default_target() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        // amend without head commit
        fs::write(repository.path().join("file2.txt"), "content").unwrap();
        let to_amend: branch::Ownership = "file2.txt:1-2".parse().unwrap();
        assert!(matches!(
            controller
                .amend(&project_id, &branch_id, &to_amend)
                .await
                .unwrap_err(),
            ControllerError::Action(errors::AmendError::BranchHasNoCommits)
        ));
    }

    #[tokio::test]
    async fn forcepush_allowed() {
        let Test {
            repository,
            project_id,
            controller,
            projects,
            ..
        } = Test::default();

        projects
            .update(&projects::UpdateRequest {
                id: project_id,
                ok_with_force_push: Some(false),
                ..Default::default()
            })
            .await
            .unwrap();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        projects
            .update(&projects::UpdateRequest {
                id: project_id,
                ok_with_force_push: Some(true),
                ..Default::default()
            })
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            // create commit
            fs::write(repository.path().join("file.txt"), "content").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap();
        };

        controller
            .push_virtual_branch(&project_id, &branch_id, false)
            .await
            .unwrap();

        {
            // amend another hunk
            fs::write(repository.path().join("file2.txt"), "content2").unwrap();
            let to_amend: branch::Ownership = "file2.txt:1-2".parse().unwrap();
            controller
                .amend(&project_id, &branch_id, &to_amend)
                .await
                .unwrap();

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert!(branch.requires_force);
            assert_eq!(branch.commits.len(), 1);
            assert_eq!(branch.files.len(), 0);
            assert_eq!(branch.commits[0].files.len(), 2);
        }
    }

    #[tokio::test]
    async fn forcepush_forbidden() {
        let Test {
            repository,
            project_id,
            controller,
            projects,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        projects
            .update(&projects::UpdateRequest {
                id: project_id,
                ok_with_force_push: Some(false),
                ..Default::default()
            })
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            // create commit
            fs::write(repository.path().join("file.txt"), "content").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap();
        };

        controller
            .push_virtual_branch(&project_id, &branch_id, false)
            .await
            .unwrap();

        {
            fs::write(repository.path().join("file2.txt"), "content2").unwrap();
            let to_amend: branch::Ownership = "file2.txt:1-2".parse().unwrap();
            assert!(matches!(
                controller
                    .amend(&project_id, &branch_id, &to_amend)
                    .await
                    .unwrap_err(),
                ControllerError::Action(errors::AmendError::ForcePushNotAllowed(_))
            ));
        }
    }

    #[tokio::test]
    async fn non_locked_hunk() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            // create commit
            fs::write(repository.path().join("file.txt"), "content").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap();

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert_eq!(branch.commits.len(), 1);
            assert_eq!(branch.files.len(), 0);
            assert_eq!(branch.commits[0].files.len(), 1);
        };

        {
            // amend another hunk
            fs::write(repository.path().join("file2.txt"), "content2").unwrap();
            let to_amend: branch::Ownership = "file2.txt:1-2".parse().unwrap();
            controller
                .amend(&project_id, &branch_id, &to_amend)
                .await
                .unwrap();

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert_eq!(branch.commits.len(), 1);
            assert_eq!(branch.files.len(), 0);
            assert_eq!(branch.commits[0].files.len(), 2);
        }
    }

    #[tokio::test]
    async fn locked_hunk() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            // create commit
            fs::write(repository.path().join("file.txt"), "content").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap();

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert_eq!(branch.commits.len(), 1);
            assert_eq!(branch.files.len(), 0);
            assert_eq!(branch.commits[0].files.len(), 1);
            assert_eq!(
                branch.commits[0].files[0].hunks[0].diff,
                "@@ -0,0 +1 @@\n+content\n\\ No newline at end of file\n"
            );
        };

        {
            // amend another hunk
            fs::write(repository.path().join("file.txt"), "more content").unwrap();
            let to_amend: branch::Ownership = "file.txt:1-2".parse().unwrap();
            controller
                .amend(&project_id, &branch_id, &to_amend)
                .await
                .unwrap();

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();

            assert_eq!(branch.commits.len(), 1);
            assert_eq!(branch.files.len(), 0);
            assert_eq!(branch.commits[0].files.len(), 1);
            assert_eq!(
                branch.commits[0].files[0].hunks[0].diff,
                "@@ -0,0 +1 @@\n+more content\n\\ No newline at end of file\n"
            );
        }
    }

    #[tokio::test]
    async fn non_existing_ownership() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            // create commit
            fs::write(repository.path().join("file.txt"), "content").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap();

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|b| b.id == branch_id)
                .unwrap();
            assert_eq!(branch.commits.len(), 1);
            assert_eq!(branch.files.len(), 0);
            assert_eq!(branch.commits[0].files.len(), 1);
        };

        {
            // amend non existing hunk
            let to_amend: branch::Ownership = "file2.txt:1-2".parse().unwrap();
            assert!(matches!(
                controller
                    .amend(&project_id, &branch_id, &to_amend)
                    .await
                    .unwrap_err(),
                ControllerError::Action(errors::AmendError::TargetOwnerhshipNotFound(_))
            ));
        }
    }
}

mod init {
    use super::*;

    #[tokio::test]
    async fn twice() {
        let data_dir = paths::data_dir();
        let keys = keys::Controller::from(&data_dir);
        let projects = projects::Controller::from(&data_dir);
        let users = users::Controller::from(&data_dir);
        let helper = git::credentials::Helper::from(&data_dir);

        let test_project = TestProject::default();

        let controller = Controller::new(&data_dir, &projects, &users, &keys, &helper);

        {
            let project = projects
                .add(test_project.path())
                .expect("failed to add project");
            controller
                .set_base_branch(&project.id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();
            assert!(controller
                .list_virtual_branches(&project.id)
                .await
                .unwrap()
                .is_empty());
            projects.delete(&project.id).await.unwrap();
            controller
                .list_virtual_branches(&project.id)
                .await
                .unwrap_err();
        }

        {
            let project = projects.add(test_project.path()).unwrap();
            controller
                .set_base_branch(&project.id, &"refs/remotes/origin/master".parse().unwrap())
                .await
                .unwrap();

            // even though project is on gitbutler/integration, we should not import it
            assert!(controller
                .list_virtual_branches(&project.id)
                .await
                .unwrap()
                .is_empty());
        }
    }

    #[tokio::test]
    async fn dirty_non_target() {
        // a situation when you initialize project while being on the local verison of the master
        // that has uncommited changes.
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        repository.checkout(&"refs/heads/some-feature".parse().unwrap());

        fs::write(repository.path().join("file.txt"), "content").unwrap();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert_eq!(branches[0].files.len(), 1);
        assert_eq!(branches[0].files[0].hunks.len(), 1);
        assert!(branches[0].upstream.is_none());
        assert_eq!(branches[0].name, "some-feature");
    }

    #[tokio::test]
    async fn dirty_target() {
        // a situation when you initialize project while being on the local verison of the master
        // that has uncommited changes.
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        fs::write(repository.path().join("file.txt"), "content").unwrap();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert_eq!(branches[0].files.len(), 1);
        assert_eq!(branches[0].files[0].hunks.len(), 1);
        assert!(branches[0].upstream.is_none());
        assert_eq!(branches[0].name, "master");
    }

    #[tokio::test]
    async fn commit_on_non_target_local() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        repository.checkout(&"refs/heads/some-feature".parse().unwrap());
        fs::write(repository.path().join("file.txt"), "content").unwrap();
        repository.commit_all("commit on target");

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert!(branches[0].files.is_empty());
        assert_eq!(branches[0].commits.len(), 1);
        assert!(branches[0].upstream.is_none());
        assert_eq!(branches[0].name, "some-feature");
    }

    #[tokio::test]
    async fn commit_on_non_target_remote() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        repository.checkout(&"refs/heads/some-feature".parse().unwrap());
        fs::write(repository.path().join("file.txt"), "content").unwrap();
        repository.commit_all("commit on target");
        repository.push_branch(&"refs/heads/some-feature".parse().unwrap());

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert!(branches[0].files.is_empty());
        assert_eq!(branches[0].commits.len(), 1);
        assert!(branches[0].upstream.is_some());
        assert_eq!(branches[0].name, "some-feature");
    }

    #[tokio::test]
    async fn commit_on_target() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        fs::write(repository.path().join("file.txt"), "content").unwrap();
        repository.commit_all("commit on target");

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert!(branches[0].files.is_empty());
        assert_eq!(branches[0].commits.len(), 1);
        assert!(branches[0].upstream.is_none());
        assert_eq!(branches[0].name, "master");
    }

    #[tokio::test]
    async fn submodule() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        let submodule_url: git::Url = TestProject::default()
            .path()
            .display()
            .to_string()
            .parse()
            .unwrap();
        repository.add_submodule(&submodule_url, path::Path::new("submodule"));

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert_eq!(branches[0].files.len(), 1);
        assert_eq!(branches[0].files[0].hunks.len(), 1);
    }
}

mod squash {
    use super::*;

    #[tokio::test]
    async fn head() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            fs::write(repository.path().join("file one.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap()
        };

        {
            fs::write(repository.path().join("file two.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit two", None, false)
                .await
                .unwrap()
        };

        {
            fs::write(repository.path().join("file three.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit three", None, false)
                .await
                .unwrap()
        };

        let commit_four_oid = {
            fs::write(repository.path().join("file four.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit four", None, false)
                .await
                .unwrap()
        };

        controller
            .squash(&project_id, &branch_id, commit_four_oid)
            .await
            .unwrap();

        let branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == branch_id)
            .unwrap();

        let descriptions = branch
            .commits
            .iter()
            .map(|c| c.description.clone())
            .collect::<Vec<_>>();
        assert_eq!(
            descriptions,
            vec!["commit three\ncommit four", "commit two", "commit one"]
        );
    }

    #[tokio::test]
    async fn middle() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            fs::write(repository.path().join("file one.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap()
        };

        let commit_two_oid = {
            fs::write(repository.path().join("file two.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit two", None, false)
                .await
                .unwrap()
        };

        {
            fs::write(repository.path().join("file three.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit three", None, false)
                .await
                .unwrap()
        };

        {
            fs::write(repository.path().join("file four.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit four", None, false)
                .await
                .unwrap()
        };

        controller
            .squash(&project_id, &branch_id, commit_two_oid)
            .await
            .unwrap();

        let branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == branch_id)
            .unwrap();

        let descriptions = branch
            .commits
            .iter()
            .map(|c| c.description.clone())
            .collect::<Vec<_>>();
        assert_eq!(
            descriptions,
            vec!["commit four", "commit three", "commit one\ncommit two"]
        );
    }

    #[tokio::test]
    async fn forcepush_allowed() {
        let Test {
            repository,
            project_id,
            controller,
            projects,
            ..
        } = Test::default();

        projects
            .update(&projects::UpdateRequest {
                id: project_id,
                ok_with_force_push: Some(true),
                ..Default::default()
            })
            .await
            .unwrap();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            fs::write(repository.path().join("file one.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap()
        };

        controller
            .push_virtual_branch(&project_id, &branch_id, false)
            .await
            .unwrap();

        let commit_two_oid = {
            fs::write(repository.path().join("file two.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit two", None, false)
                .await
                .unwrap()
        };

        {
            fs::write(repository.path().join("file three.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit three", None, false)
                .await
                .unwrap()
        };

        {
            fs::write(repository.path().join("file four.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit four", None, false)
                .await
                .unwrap()
        };

        controller
            .squash(&project_id, &branch_id, commit_two_oid)
            .await
            .unwrap();

        let branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == branch_id)
            .unwrap();

        let descriptions = branch
            .commits
            .iter()
            .map(|c| c.description.clone())
            .collect::<Vec<_>>();
        assert_eq!(
            descriptions,
            vec!["commit four", "commit three", "commit one\ncommit two"]
        );
        assert!(branch.requires_force);
    }

    #[tokio::test]
    async fn forcepush_forbidden() {
        let Test {
            repository,
            project_id,
            controller,
            projects,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            fs::write(repository.path().join("file one.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap()
        };

        controller
            .push_virtual_branch(&project_id, &branch_id, false)
            .await
            .unwrap();

        projects
            .update(&projects::UpdateRequest {
                id: project_id,
                ok_with_force_push: Some(false),
                ..Default::default()
            })
            .await
            .unwrap();

        let commit_two_oid = {
            fs::write(repository.path().join("file two.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit two", None, false)
                .await
                .unwrap()
        };

        {
            fs::write(repository.path().join("file three.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit three", None, false)
                .await
                .unwrap()
        };

        {
            fs::write(repository.path().join("file four.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit four", None, false)
                .await
                .unwrap()
        };

        assert!(matches!(
            controller
                .squash(&project_id, &branch_id, commit_two_oid)
                .await
                .unwrap_err(),
            ControllerError::Action(errors::SquashError::ForcePushNotAllowed(_))
        ));
    }

    #[tokio::test]
    async fn root() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        let commit_one_oid = {
            fs::write(repository.path().join("file one.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap()
        };

        assert!(matches!(
            controller
                .squash(&project_id, &branch_id, commit_one_oid)
                .await
                .unwrap_err(),
            ControllerError::Action(errors::SquashError::CantSquashRootCommit)
        ));
    }
}

mod update_commit_message {
    use super::*;

    #[tokio::test]
    async fn head() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            fs::write(repository.path().join("file one.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap()
        };

        {
            fs::write(repository.path().join("file two.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit two", None, false)
                .await
                .unwrap()
        };

        let commit_three_oid = {
            fs::write(repository.path().join("file three.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit three", None, false)
                .await
                .unwrap()
        };

        controller
            .update_commit_message(
                &project_id,
                &branch_id,
                commit_three_oid,
                "commit three updated",
            )
            .await
            .unwrap();

        let branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == branch_id)
            .unwrap();

        let descriptions = branch
            .commits
            .iter()
            .map(|c| c.description.clone())
            .collect::<Vec<_>>();

        assert_eq!(
            descriptions,
            vec!["commit three updated", "commit two", "commit one"]
        );
    }

    #[tokio::test]
    async fn middle() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        {
            fs::write(repository.path().join("file one.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap()
        };

        let commit_two_oid = {
            fs::write(repository.path().join("file two.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit two", None, false)
                .await
                .unwrap()
        };

        {
            fs::write(repository.path().join("file three.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit three", None, false)
                .await
                .unwrap()
        };

        controller
            .update_commit_message(
                &project_id,
                &branch_id,
                commit_two_oid,
                "commit two updated",
            )
            .await
            .unwrap();

        let branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == branch_id)
            .unwrap();

        let descriptions = branch
            .commits
            .iter()
            .map(|c| c.description.clone())
            .collect::<Vec<_>>();
        assert_eq!(
            descriptions,
            vec!["commit three", "commit two updated", "commit one"]
        );
    }

    #[tokio::test]
    async fn forcepush_allowed() {
        let Test {
            repository,
            project_id,
            controller,
            projects,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        projects
            .update(&projects::UpdateRequest {
                id: project_id,
                ok_with_force_push: Some(true),
                ..Default::default()
            })
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        let commit_one_oid = {
            fs::write(repository.path().join("file one.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap()
        };

        controller
            .push_virtual_branch(&project_id, &branch_id, false)
            .await
            .unwrap();

        controller
            .update_commit_message(
                &project_id,
                &branch_id,
                commit_one_oid,
                "commit one updated",
            )
            .await
            .unwrap();

        let branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == branch_id)
            .unwrap();

        let descriptions = branch
            .commits
            .iter()
            .map(|c| c.description.clone())
            .collect::<Vec<_>>();
        assert_eq!(descriptions, vec!["commit one updated"]);
        assert!(branch.requires_force);
    }

    #[tokio::test]
    async fn forcepush_forbidden() {
        let Test {
            repository,
            project_id,
            controller,
            projects,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        projects
            .update(&projects::UpdateRequest {
                id: project_id,
                ok_with_force_push: Some(false),
                ..Default::default()
            })
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        let commit_one_oid = {
            fs::write(repository.path().join("file one.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap()
        };

        controller
            .push_virtual_branch(&project_id, &branch_id, false)
            .await
            .unwrap();

        assert!(matches!(
            controller
                .update_commit_message(
                    &project_id,
                    &branch_id,
                    commit_one_oid,
                    "commit one updated",
                )
                .await
                .unwrap_err(),
            ControllerError::Action(errors::UpdateCommitMessageError::ForcePushNotAllowed(_))
        ));
    }

    #[tokio::test]
    async fn root() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        let commit_one_oid = {
            fs::write(repository.path().join("file one.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap()
        };

        {
            fs::write(repository.path().join("file two.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit two", None, false)
                .await
                .unwrap()
        };

        {
            fs::write(repository.path().join("file three.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit three", None, false)
                .await
                .unwrap()
        };

        controller
            .update_commit_message(
                &project_id,
                &branch_id,
                commit_one_oid,
                "commit one updated",
            )
            .await
            .unwrap();

        let branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == branch_id)
            .unwrap();

        let descriptions = branch
            .commits
            .iter()
            .map(|c| c.description.clone())
            .collect::<Vec<_>>();
        assert_eq!(
            descriptions,
            vec!["commit three", "commit two", "commit one updated"]
        );
    }

    #[tokio::test]
    async fn empty() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        let commit_one_oid = {
            fs::write(repository.path().join("file one.txt"), "").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "commit one", None, false)
                .await
                .unwrap()
        };

        assert!(matches!(
            controller
                .update_commit_message(&project_id, &branch_id, commit_one_oid, "",)
                .await,
            Err(ControllerError::Action(
                errors::UpdateCommitMessageError::EmptyMessage
            ))
        ));
    }
}

mod create_virtual_branch_from_branch {
    use super::*;

    #[tokio::test]
    async fn integration() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_name = {
            // make a remote branch

            let branch_id = controller
                .create_virtual_branch(&project_id, &super::branch::BranchCreateRequest::default())
                .await
                .unwrap();

            std::fs::write(repository.path().join("file.txt"), "first\n").unwrap();
            controller
                .create_commit(&project_id, &branch_id, "first", None, false)
                .await
                .unwrap();
            controller
                .push_virtual_branch(&project_id, &branch_id, false)
                .await
                .unwrap();

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|branch| branch.id == branch_id)
                .unwrap();

            let name = branch.upstream.unwrap().name;

            controller
                .delete_virtual_branch(&project_id, &branch_id)
                .await
                .unwrap();

            name
        };

        // checkout a existing remote branch
        let branch_id = controller
            .create_virtual_branch_from_branch(&project_id, &branch_name)
            .await
            .unwrap();

        {
            // add a commit
            std::fs::write(repository.path().join("file.txt"), "first\nsecond").unwrap();

            controller
                .create_commit(&project_id, &branch_id, "second", None, false)
                .await
                .unwrap();
        }

        {
            // meanwhile, there is a new commit on master
            repository.checkout(&"refs/heads/master".parse().unwrap());
            std::fs::write(repository.path().join("another.txt"), "").unwrap();
            repository.commit_all("another");
            repository.push_branch(&"refs/heads/master".parse().unwrap());
            repository.checkout(&"refs/heads/gitbutler/integration".parse().unwrap());
        }

        {
            // merge branch into master
            controller
                .push_virtual_branch(&project_id, &branch_id, false)
                .await
                .unwrap();

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|branch| branch.id == branch_id)
                .unwrap();

            assert!(branch.commits[0].is_remote);
            assert!(!branch.commits[0].is_integrated);
            assert!(branch.commits[1].is_remote);
            assert!(!branch.commits[1].is_integrated);

            repository.rebase_and_merge(&branch_name);
        }

        {
            // should mark commits as integrated
            controller.fetch_from_target(&project_id).await.unwrap();

            let branch = controller
                .list_virtual_branches(&project_id)
                .await
                .unwrap()
                .into_iter()
                .find(|branch| branch.id == branch_id)
                .unwrap();

            assert!(branch.commits[0].is_remote);
            assert!(branch.commits[0].is_integrated);
            assert!(branch.commits[1].is_remote);
            assert!(branch.commits[1].is_integrated);
        }
    }

    #[tokio::test]
    async fn no_conflicts() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        {
            // create a remote branch
            let branch_name: git::LocalRefname = "refs/heads/branch".parse().unwrap();
            repository.checkout(&branch_name);
            fs::write(repository.path().join("file.txt"), "first").unwrap();
            repository.commit_all("first");
            repository.push_branch(&branch_name);
            repository.checkout(&"refs/heads/master".parse().unwrap());
        }

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert!(branches.is_empty());

        let branch_id = controller
            .create_virtual_branch_from_branch(
                &project_id,
                &"refs/remotes/origin/branch".parse().unwrap(),
            )
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert_eq!(branches[0].id, branch_id);
        assert_eq!(branches[0].commits.len(), 1);
        assert_eq!(branches[0].commits[0].description, "first");
    }

    #[tokio::test]
    async fn conflicts_with_uncommited() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        {
            // create a remote branch
            let branch_name: git::LocalRefname = "refs/heads/branch".parse().unwrap();
            repository.checkout(&branch_name);
            fs::write(repository.path().join("file.txt"), "first").unwrap();
            repository.commit_all("first");
            repository.push_branch(&branch_name);
            repository.checkout(&"refs/heads/master".parse().unwrap());
        }

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        // create a local branch that conflicts with remote
        {
            std::fs::write(repository.path().join("file.txt"), "conflict").unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);
        };

        // branch should be created unapplied, because of the conflict

        let new_branch_id = controller
            .create_virtual_branch_from_branch(
                &project_id,
                &"refs/remotes/origin/branch".parse().unwrap(),
            )
            .await
            .unwrap();
        let new_branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|branch| branch.id == new_branch_id)
            .unwrap();
        assert!(!new_branch.active);
        assert_eq!(new_branch.commits.len(), 1);
        assert!(new_branch.upstream.is_some());
    }

    #[tokio::test]
    async fn conflicts_with_commited() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        {
            // create a remote branch
            let branch_name: git::LocalRefname = "refs/heads/branch".parse().unwrap();
            repository.checkout(&branch_name);
            fs::write(repository.path().join("file.txt"), "first").unwrap();
            repository.commit_all("first");
            repository.push_branch(&branch_name);
            repository.checkout(&"refs/heads/master".parse().unwrap());
        }

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        // create a local branch that conflicts with remote
        {
            std::fs::write(repository.path().join("file.txt"), "conflict").unwrap();

            let branches = controller.list_virtual_branches(&project_id).await.unwrap();
            assert_eq!(branches.len(), 1);

            controller
                .create_commit(&project_id, &branches[0].id, "hej", None, false)
                .await
                .unwrap();
        };

        // branch should be created unapplied, because of the conflict

        let new_branch_id = controller
            .create_virtual_branch_from_branch(
                &project_id,
                &"refs/remotes/origin/branch".parse().unwrap(),
            )
            .await
            .unwrap();
        let new_branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|branch| branch.id == new_branch_id)
            .unwrap();
        assert!(!new_branch.active);
        assert_eq!(new_branch.commits.len(), 1);
        assert!(new_branch.upstream.is_some());
    }

    #[tokio::test]
    async fn from_default_target() {
        let Test {
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        // branch should be created unapplied, because of the conflict

        assert!(matches!(
            controller
                .create_virtual_branch_from_branch(
                    &project_id,
                    &"refs/remotes/origin/master".parse().unwrap(),
                )
                .await
                .unwrap_err(),
            ControllerError::Action(
                errors::CreateVirtualBranchFromBranchError::CantMakeBranchFromDefaultTarget
            )
        ));
    }

    #[tokio::test]
    async fn from_non_existent_branch() {
        let Test {
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        // branch should be created unapplied, because of the conflict

        assert!(matches!(
            controller
                .create_virtual_branch_from_branch(
                    &project_id,
                    &"refs/remotes/origin/branch".parse().unwrap(),
                )
                .await
                .unwrap_err(),
            ControllerError::Action(errors::CreateVirtualBranchFromBranchError::BranchNotFound(
                _
            ))
        ));
    }

    #[tokio::test]
    async fn from_state_remote_branch() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        {
            // create a remote branch
            let branch_name: git::LocalRefname = "refs/heads/branch".parse().unwrap();
            repository.checkout(&branch_name);
            fs::write(repository.path().join("file.txt"), "branch commit").unwrap();
            repository.commit_all("branch commit");
            repository.push_branch(&branch_name);
            repository.checkout(&"refs/heads/master".parse().unwrap());

            // make remote branch stale
            std::fs::write(repository.path().join("antoher_file.txt"), "master commit").unwrap();
            repository.commit_all("master commit");
            repository.push();
        }

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let branch_id = controller
            .create_virtual_branch_from_branch(
                &project_id,
                &"refs/remotes/origin/branch".parse().unwrap(),
            )
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert_eq!(branches[0].id, branch_id);
        assert_eq!(branches[0].commits.len(), 1);
        assert!(branches[0].files.is_empty());
        assert_eq!(branches[0].commits[0].description, "branch commit");
    }
}

mod selected_for_changes {
    use super::*;

    #[tokio::test]
    async fn unapplying_selected_branch_selects_anther() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        std::fs::write(repository.path().join("file one.txt"), "").unwrap();

        // first branch should be created as default
        let b_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        // if default branch exists, new branch should not be created as default
        let b2_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();

        let b = branches.iter().find(|b| b.id == b_id).unwrap();

        let b2 = branches.iter().find(|b| b.id == b2_id).unwrap();

        assert!(b.selected_for_changes);
        assert!(!b2.selected_for_changes);

        controller
            .unapply_virtual_branch(&project_id, &b_id)
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();

        assert_eq!(branches.len(), 2);
        assert_eq!(branches[0].id, b.id);
        assert!(!branches[0].selected_for_changes);
        assert!(!branches[0].active);
        assert_eq!(branches[1].id, b2.id);
        assert!(branches[1].selected_for_changes);
        assert!(branches[1].active);
    }

    #[tokio::test]
    async fn deleting_selected_branch_selects_anther() {
        let Test {
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        // first branch should be created as default
        let b_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        // if default branch exists, new branch should not be created as default
        let b2_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();

        let b = branches.iter().find(|b| b.id == b_id).unwrap();

        let b2 = branches.iter().find(|b| b.id == b2_id).unwrap();

        assert!(b.selected_for_changes);
        assert!(!b2.selected_for_changes);

        controller
            .delete_virtual_branch(&project_id, &b_id)
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();

        assert_eq!(branches.len(), 1);
        assert_eq!(branches[0].id, b2.id);
        assert!(branches[0].selected_for_changes);
    }

    #[tokio::test]
    async fn create_virtual_branch_should_set_selected_for_changes() {
        let Test {
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        // first branch should be created as default
        let b_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();
        let branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == b_id)
            .unwrap();
        assert!(branch.selected_for_changes);

        // if default branch exists, new branch should not be created as default
        let b_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();
        let branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == b_id)
            .unwrap();
        assert!(!branch.selected_for_changes);

        // explicitly don't make this one default
        let b_id = controller
            .create_virtual_branch(
                &project_id,
                &branch::BranchCreateRequest {
                    selected_for_changes: Some(false),
                    ..Default::default()
                },
            )
            .await
            .unwrap();
        let branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == b_id)
            .unwrap();
        assert!(!branch.selected_for_changes);

        // explicitly make this one default
        let b_id = controller
            .create_virtual_branch(
                &project_id,
                &branch::BranchCreateRequest {
                    selected_for_changes: Some(true),
                    ..Default::default()
                },
            )
            .await
            .unwrap();
        let branch = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == b_id)
            .unwrap();
        assert!(branch.selected_for_changes);
    }

    #[tokio::test]
    async fn update_virtual_branch_should_reset_selected_for_changes() {
        let Test {
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let b1_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();
        let b1 = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == b1_id)
            .unwrap();
        assert!(b1.selected_for_changes);

        let b2_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();
        let b2 = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == b2_id)
            .unwrap();
        assert!(!b2.selected_for_changes);

        controller
            .update_virtual_branch(
                &project_id,
                branch::BranchUpdateRequest {
                    id: b2_id,
                    selected_for_changes: Some(true),
                    ..Default::default()
                },
            )
            .await
            .unwrap();

        let b1 = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == b1_id)
            .unwrap();
        assert!(!b1.selected_for_changes);

        let b2 = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == b2_id)
            .unwrap();
        assert!(b2.selected_for_changes);
    }

    #[tokio::test]
    async fn unapply_virtual_branch_should_reset_selected_for_changes() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        let b1_id = controller
            .create_virtual_branch(&project_id, &branch::BranchCreateRequest::default())
            .await
            .unwrap();
        std::fs::write(repository.path().join("file.txt"), "content").unwrap();

        let b1 = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == b1_id)
            .unwrap();
        assert!(b1.selected_for_changes);

        controller
            .unapply_virtual_branch(&project_id, &b1_id)
            .await
            .unwrap();

        let b1 = controller
            .list_virtual_branches(&project_id)
            .await
            .unwrap()
            .into_iter()
            .find(|b| b.id == b1_id)
            .unwrap();
        assert!(!b1.selected_for_changes);
    }

    #[tokio::test]
    async fn hunks_distribution() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        std::fs::write(repository.path().join("file.txt"), "content").unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches[0].files.len(), 1);

        controller
            .create_virtual_branch(
                &project_id,
                &branch::BranchCreateRequest {
                    selected_for_changes: Some(true),
                    ..Default::default()
                },
            )
            .await
            .unwrap();
        std::fs::write(repository.path().join("another_file.txt"), "content").unwrap();
        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches[0].files.len(), 1);
        assert_eq!(branches[1].files.len(), 1);
    }

    #[tokio::test]
    async fn applying_first_branch() {
        let Test {
            repository,
            project_id,
            controller,
            ..
        } = Test::default();

        controller
            .set_base_branch(&project_id, &"refs/remotes/origin/master".parse().unwrap())
            .await
            .unwrap();

        std::fs::write(repository.path().join("file.txt"), "content").unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);

        controller
            .unapply_virtual_branch(&project_id, &branches[0].id)
            .await
            .unwrap();
        controller
            .apply_virtual_branch(&project_id, &branches[0].id)
            .await
            .unwrap();

        let branches = controller.list_virtual_branches(&project_id).await.unwrap();
        assert_eq!(branches.len(), 1);
        assert!(branches[0].active);
        assert!(branches[0].selected_for_changes);
    }
}