git-next/src/server/config/tests.rs

use pretty_assertions::assert_eq;

use crate::filesystem::FileSystem;

use super::*;

#[test]
fn load_should_parse_server_config() -> Result<(), OneOf<(std::io::Error, toml::de::Error)>> {
    let fs = FileSystem::new_temp().map_err(OneOf::new)?;
    fs.write_file(
            "git-next-server.toml",
            r#"
            [webhook]
            url = "http://localhost:9909/webhook"

            [storage]
            path = "/opt/git-next/data"

            [forge.default]
            forge_type = "MockForge"
            hostname = "git.example.net"
            user = "Bob"
            token = "API-Token"

            [forge.default.repos]
            hello = { repo = "user/hello", branch = "main", gitdir = "/opt/git/user/hello.git" }
            world = { repo = "user/world", branch = "master", main = "main", next = "next", dev = "dev" }

            [forge.default.repos.sam]
            repo = "user/sam"
            branch = "main"
            main = "master"
            next = "upcoming"
            dev = "sam-dev"
        "#,
        )
        .map_err(OneOf::new)?;
    let config = ServerConfig::load(&fs)?;
    let expected = ServerConfig {
        webhook: Webhook {
            url: "http://localhost:9909/webhook".to_string(),
        },
        storage: ServerStorage {
            path: "/opt/git-next/data".into(),
        },
        forge: HashMap::from([(
            "default".to_string(),
            ForgeConfig {
                forge_type: ForgeType::MockForge,
                hostname: "git.example.net".to_string(),
                user: "Bob".to_string(),
                token: "API-Token".to_string(),
                repos: HashMap::from([
                    (
                        "hello".to_string(),
                        ServerRepoConfig {
                            repo: "user/hello".to_string(),
                            branch: "main".to_string(),
                            gitdir: Some("/opt/git/user/hello.git".into()),
                            main: None,
                            next: None,
                            dev: None,
                        },
                    ),
                    (
                        "world".to_string(),
                        ServerRepoConfig {
                            repo: "user/world".to_string(),
                            branch: "master".to_string(),
                            gitdir: None,
                            main: Some("main".to_string()),
                            next: Some("next".to_string()),
                            dev: Some("dev".to_string()),
                        },
                    ),
                    (
                        "sam".to_string(),
                        ServerRepoConfig {
                            repo: "user/sam".to_string(),
                            branch: "main".to_string(),
                            gitdir: None,
                            main: Some("master".to_string()),
                            next: Some("upcoming".to_string()),
                            dev: Some("sam-dev".to_string()),
                        },
                    ),
                ]),
            },
        )]),
    };
    assert_eq!(config, expected, "ServerConfig");

    if let Some(forge) = config.forge.get("world") {
        if let Some(repo) = forge.repos.get("sam") {
            let repo_config = repo.repo_config();
            let expected = Some(RepoConfig {
                branches: RepoBranches {
                    main: "master".to_string(),
                    next: "upcoming".to_string(),
                    dev: "sam-dev".to_string(),
                },
            });
            assert_eq!(repo_config, expected, "RepoConfig");
        }
    }

    Ok(())
}

#[test]
fn test_repo_config_load() -> Result<(), OneOf<(toml::de::Error,)>> {
    let toml = r#"
            [branches]
            main = "main"
            next = "next"
            dev = "dev"

            [options]
        "#;
    let config = RepoConfig::load(toml)?;

    assert_eq!(
        config,
        RepoConfig {
            branches: RepoBranches {
                main: "main".to_string(),
                next: "next".to_string(),
                dev: "dev".to_string(),
            },
        }
    );

    Ok(())
}