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

242 lines
7.6 KiB
Rust
Raw Normal View History

2024-05-14 07:59:31 +01:00
use std::collections::BTreeMap;
use assert2::let_assert;
use git_next_config::{
ForgeType, GitDir, Hostname, RepoBranches, RepoConfig, RepoConfigSource, RepoPath,
ServerRepoConfig,
};
use git_next_git::{self as git, Generation, GitRemote, Repository};
use gix::remote::Direction;
use kxio::fs;
use pretty_assertions::assert_eq;
use crate::gitforge::tests::common;
use super::*;
type Result<T> = core::result::Result<T, Box<dyn std::error::Error>>;
#[test]
fn load_should_parse_server_config() -> Result<()> {
2024-04-28 08:05:09 +01:00
let fs = fs::temp()?;
fs.file_write(
&fs.base().join("git-next-server.toml"),
r#"
[http]
addr = "0.0.0.0"
port = 8080
[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"
"#,
)
2024-04-28 08:05:09 +01:00
?;
let_assert!(Ok(config) = ServerConfig::load(&fs));
let expected = ServerConfig {
http: Http {
addr: "0.0.0.0".to_string(),
port: 8080,
},
webhook: Webhook {
url: "http://localhost:9909/webhook".to_string(),
},
storage: ServerStorage {
path: "/opt/git-next/data".into(),
},
forge: HashMap::from([(
"default".to_string(),
ForgeConfig::new(
ForgeType::MockForge,
"git.example.net".to_string(),
"Bob".to_string(),
"API-Token".to_string(),
BTreeMap::from([
(
"hello".to_string(),
ServerRepoConfig::new(
"user/hello".to_string(),
"main".to_string(),
Some("/opt/git/user/hello.git".into()),
None,
None,
None,
),
),
(
"world".to_string(),
ServerRepoConfig::new(
"user/world".to_string(),
"master".to_string(),
None,
Some("main".to_string()),
Some("next".to_string()),
Some("dev".to_string()),
),
),
(
"sam".to_string(),
ServerRepoConfig::new(
"user/sam".to_string(),
"main".to_string(),
None,
Some("master".to_string()),
Some("upcoming".to_string()),
Some("sam-dev".to_string()),
),
),
]),
),
)]),
};
assert_eq!(config, expected, "ServerConfig");
if let Some(forge) = config.forge.get("world") {
if let Some(repo) = forge.get_repo("sam") {
let repo_config = repo.repo_config();
let expected = Some(RepoConfig::new(
RepoBranches::new(
"master".to_string(),
"upcoming".to_string(),
"sam-dev".to_string(),
),
RepoConfigSource::Server,
));
assert_eq!(repo_config, expected, "RepoConfig");
}
}
Ok(())
}
#[test]
fn test_repo_config_load() -> Result<()> {
let toml = r#"[branches]
main = "main"
next = "next"
dev = "dev"
[options]
"#;
let config = RepoConfig::load(toml)?;
assert_eq!(
config,
RepoConfig::new(
RepoBranches::new("main".to_string(), "next".to_string(), "dev".to_string(),),
RepoConfigSource::Repo
)
);
Ok(())
}
#[test]
fn gitdir_should_display_as_pathbuf() {
//given
let gitdir = GitDir::from("foo/dir");
//when
let result = format!("{}", gitdir);
//then
assert_eq!(result, "foo/dir");
}
#[test]
// NOTE: this test assumes it is being run in a cloned worktree from the project's home repo:
// git.kemitix.net:kemitix/git-next
// If the default push remote is something else, then this test will fail
fn repo_details_find_default_push_remote_finds_correct_remote() -> Result<()> {
let cli_crate_dir = std::env::current_dir().map_err(git::validate::Error::Io)?;
let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent()));
let mut repo_details = common::repo_details(
1,
Generation::new(),
common::forge_details(1, ForgeType::MockForge),
None,
2024-05-11 18:58:47 +01:00
GitDir::new(root), // Server GitDir - should be ignored
);
repo_details.forge = repo_details
.forge
.with_hostname(Hostname::new("git.kemitix.net"));
repo_details.repo_path = RepoPath::new("kemitix/git-next".to_string());
let gitdir = &repo_details.gitdir;
let repository = Repository::open(gitdir)?;
let found_git_remote = git::validate::find_default_remote(&repository, Direction::Push)?;
let config_git_remote = repo_details.git_remote();
assert_eq!(
found_git_remote, config_git_remote,
"Default Push Remote must match config"
);
Ok(())
}
#[test]
fn gitdir_validate_should_pass_a_valid_git_repo() -> Result<()> {
let cli_crate_dir = std::env::current_dir().map_err(git::validate::Error::Io)?;
let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent()));
let mut repo_details = common::repo_details(
1,
Generation::new(),
common::forge_details(1, ForgeType::MockForge),
None,
2024-05-11 18:58:47 +01:00
GitDir::new(root), // Server GitDir - should be ignored
);
repo_details.forge = repo_details
.forge
.with_hostname(Hostname::new("git.kemitix.net"));
repo_details.repo_path = RepoPath::new("kemitix/git-next".to_string());
let gitdir = &repo_details.gitdir;
let repository = Repository::open(gitdir)?;
git::validate(&repository, &repo_details)?;
Ok(())
}
#[test]
fn gitdir_validate_should_fail_a_git_repo_with_wrong_remote() -> Result<()> {
let_assert!(Ok(cli_crate_dir) = std::env::current_dir().map_err(git::validate::Error::Io));
let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent()));
let mut repo_details = common::repo_details(
1,
Generation::new(),
common::forge_details(1, ForgeType::MockForge),
None,
2024-05-11 18:58:47 +01:00
GitDir::new(root), // Server GitDir - should be ignored
);
repo_details.repo_path = RepoPath::new("hello/world".to_string());
let gitdir = &repo_details.gitdir;
let repository = Repository::open(gitdir)?;
let_assert!(Err(_) = git::validate(&repository, &repo_details));
Ok(())
}
#[test]
fn git_remote_to_string_is_as_expected() {
let git_remote = GitRemote::new(Hostname::new("foo"), RepoPath::new("bar".to_string()));
let as_string = git_remote.to_string();
assert_eq!(as_string, "foo:bar");
}