437 lines
13 KiB
Rust
437 lines
13 KiB
Rust
use super::*;
|
|
use crate::config::TokenConfig;
|
|
use std::io::{Read, Write};
|
|
use std::net::TcpListener;
|
|
use std::thread;
|
|
|
|
#[test]
|
|
fn extracts_next_link() {
|
|
let mut headers = HeaderMap::new();
|
|
headers.insert(
|
|
"link",
|
|
HeaderValue::from_static("<https://example.test?page=2>; rel=\"next\", <https://example.test?page=5>; rel=\"last\""),
|
|
);
|
|
assert_eq!(next_link(&headers).unwrap(), "https://example.test?page=2");
|
|
}
|
|
|
|
#[test]
|
|
fn authenticated_clone_urls_use_provider_defaults() {
|
|
let github_site = site(ProviderKind::Github, None);
|
|
let github = ProviderClient::new(&github_site).unwrap();
|
|
assert_eq!(
|
|
github
|
|
.authenticated_clone_url("https://github.com/alice/repo.git")
|
|
.unwrap(),
|
|
"https://x-access-token:secret@github.com/alice/repo.git"
|
|
);
|
|
|
|
let gitlab_site = site(ProviderKind::Gitlab, None);
|
|
let gitlab = ProviderClient::new(&gitlab_site).unwrap();
|
|
assert_eq!(
|
|
gitlab
|
|
.authenticated_clone_url("https://gitlab.example.test/alice/repo.git")
|
|
.unwrap(),
|
|
"https://oauth2:secret@gitlab.example.test/alice/repo.git"
|
|
);
|
|
|
|
let forgejo_site = site(ProviderKind::Forgejo, None);
|
|
let forgejo = ProviderClient::new(&forgejo_site).unwrap();
|
|
assert_eq!(
|
|
forgejo
|
|
.authenticated_clone_url("https://forgejo.example.test/alice/repo.git")
|
|
.unwrap(),
|
|
"https://oauth2:secret@forgejo.example.test/alice/repo.git"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn authenticated_clone_urls_can_override_git_username() {
|
|
let gitea_site = site(ProviderKind::Gitea, Some("mirror-user".to_string()));
|
|
let client = ProviderClient::new(&gitea_site).unwrap();
|
|
|
|
assert_eq!(
|
|
client
|
|
.authenticated_clone_url("https://gitea.example.test/alice/repo.git")
|
|
.unwrap(),
|
|
"https://mirror-user:secret@gitea.example.test/alice/repo.git"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn group_paths_are_url_encoded_for_gitlab() {
|
|
assert_eq!(urlencoding("parent/child group"), "parent%2Fchild+group");
|
|
}
|
|
|
|
#[test]
|
|
fn validate_token_checks_user_endpoint_with_provider_auth_header() {
|
|
let (api_url, handle) = one_request_server("200 OK", "{}", |request| {
|
|
assert!(request.starts_with("GET /user "), "request was {request}");
|
|
assert!(
|
|
request
|
|
.to_ascii_lowercase()
|
|
.contains("authorization: bearer secret"),
|
|
"request was {request}"
|
|
);
|
|
});
|
|
let site = SiteConfig {
|
|
api_url: Some(api_url),
|
|
..site(ProviderKind::Github, None)
|
|
};
|
|
|
|
ProviderClient::new(&site)
|
|
.unwrap()
|
|
.validate_token()
|
|
.unwrap();
|
|
handle.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn validate_token_reports_provider_rejection() {
|
|
let (api_url, handle) = one_request_server("401 Unauthorized", "bad token", |request| {
|
|
assert!(request.starts_with("GET /user "), "request was {request}");
|
|
assert!(
|
|
request
|
|
.to_ascii_lowercase()
|
|
.contains("private-token: secret"),
|
|
"request was {request}"
|
|
);
|
|
});
|
|
let site = SiteConfig {
|
|
api_url: Some(api_url),
|
|
..site(ProviderKind::Gitlab, None)
|
|
};
|
|
|
|
let err = ProviderClient::new(&site)
|
|
.unwrap()
|
|
.validate_token()
|
|
.unwrap_err()
|
|
.to_string();
|
|
assert!(err.contains("401 Unauthorized"));
|
|
handle.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn detect_namespace_kind_uses_authenticated_github_api() {
|
|
let (api_url, handle) = one_request_server("200 OK", r#"{"type":"Organization"}"#, |request| {
|
|
assert!(
|
|
request.starts_with("GET /users/acme "),
|
|
"request was {request}"
|
|
);
|
|
assert!(
|
|
request
|
|
.to_ascii_lowercase()
|
|
.contains("authorization: bearer secret"),
|
|
"request was {request}"
|
|
);
|
|
});
|
|
let site = SiteConfig {
|
|
api_url: Some(api_url),
|
|
..site(ProviderKind::Github, None)
|
|
};
|
|
|
|
let kind = ProviderClient::new(&site)
|
|
.unwrap()
|
|
.detect_namespace_kind("acme")
|
|
.unwrap();
|
|
assert_eq!(kind, Some(NamespaceKind::Org));
|
|
handle.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn detect_namespace_kind_uses_authenticated_gitea_api() {
|
|
let (api_url, handle) = one_request_server("200 OK", "{}", |request| {
|
|
assert!(
|
|
request.starts_with("GET /orgs/acme "),
|
|
"request was {request}"
|
|
);
|
|
assert!(
|
|
request
|
|
.to_ascii_lowercase()
|
|
.contains("authorization: token secret"),
|
|
"request was {request}"
|
|
);
|
|
});
|
|
let site = SiteConfig {
|
|
api_url: Some(api_url),
|
|
..site(ProviderKind::Gitea, None)
|
|
};
|
|
|
|
let kind = ProviderClient::new(&site)
|
|
.unwrap()
|
|
.detect_namespace_kind("acme")
|
|
.unwrap();
|
|
assert_eq!(kind, Some(NamespaceKind::Org));
|
|
handle.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn install_webhook_posts_github_hook_when_missing() {
|
|
let (api_url, handle) = request_server(
|
|
vec![("200 OK", "[]"), ("201 Created", r#"{"id":1}"#)],
|
|
|index, request| match index {
|
|
0 => assert!(
|
|
request.starts_with("GET /repos/alice/repo/hooks "),
|
|
"request was {request}"
|
|
),
|
|
1 => {
|
|
assert!(
|
|
request.starts_with("POST /repos/alice/repo/hooks "),
|
|
"request was {request}"
|
|
);
|
|
assert!(request.contains("https://mirror.example.test/webhook"));
|
|
assert!(request.contains("secret"));
|
|
assert!(request.contains("push"));
|
|
}
|
|
_ => unreachable!(),
|
|
},
|
|
);
|
|
let site = SiteConfig {
|
|
api_url: Some(api_url),
|
|
..site(ProviderKind::Github, None)
|
|
};
|
|
let client = ProviderClient::new(&site).unwrap();
|
|
|
|
client
|
|
.install_webhook(
|
|
&EndpointConfig {
|
|
site: "github".to_string(),
|
|
kind: NamespaceKind::User,
|
|
namespace: "alice".to_string(),
|
|
},
|
|
&RemoteRepo {
|
|
name: "repo".to_string(),
|
|
clone_url: "https://github.com/alice/repo.git".to_string(),
|
|
private: true,
|
|
description: None,
|
|
},
|
|
"https://mirror.example.test/webhook",
|
|
"secret",
|
|
)
|
|
.unwrap();
|
|
handle.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn uninstall_webhook_deletes_matching_github_hook() {
|
|
let (api_url, handle) = request_server(
|
|
vec![
|
|
(
|
|
"200 OK",
|
|
r#"[{"id":42,"config":{"url":"https://mirror.example.test/webhook"}}]"#,
|
|
),
|
|
("204 No Content", ""),
|
|
],
|
|
|index, request| match index {
|
|
0 => assert!(
|
|
request.starts_with("GET /repos/alice/repo/hooks "),
|
|
"request was {request}"
|
|
),
|
|
1 => assert!(
|
|
request.starts_with("DELETE /repos/alice/repo/hooks/42 "),
|
|
"request was {request}"
|
|
),
|
|
_ => unreachable!(),
|
|
},
|
|
);
|
|
let site = SiteConfig {
|
|
api_url: Some(api_url),
|
|
..site(ProviderKind::Github, None)
|
|
};
|
|
let client = ProviderClient::new(&site).unwrap();
|
|
|
|
let removed = client
|
|
.uninstall_webhook(
|
|
&EndpointConfig {
|
|
site: "github".to_string(),
|
|
kind: NamespaceKind::User,
|
|
namespace: "alice".to_string(),
|
|
},
|
|
"repo",
|
|
"https://mirror.example.test/webhook",
|
|
)
|
|
.unwrap();
|
|
|
|
assert!(removed);
|
|
handle.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn open_pull_request_posts_github_pull_when_missing() {
|
|
let (api_url, handle) = request_server(
|
|
vec![
|
|
("200 OK", "[]"),
|
|
(
|
|
"201 Created",
|
|
r#"{"number":7,"html_url":"https://github.example.test/pull/7"}"#,
|
|
),
|
|
],
|
|
|index, request| match index {
|
|
0 => assert!(
|
|
request
|
|
.starts_with("GET /repos/alice/repo/pulls?state=open&base=main&per_page=100 "),
|
|
"request was {request}"
|
|
),
|
|
1 => {
|
|
assert!(
|
|
request.starts_with("POST /repos/alice/repo/pulls "),
|
|
"request was {request}"
|
|
);
|
|
assert!(request.contains("Resolve conflict"));
|
|
assert!(request.contains("git-sync/conflicts/main/from-b-abc123"));
|
|
assert!(request.contains("main"));
|
|
}
|
|
_ => unreachable!(),
|
|
},
|
|
);
|
|
let site = SiteConfig {
|
|
api_url: Some(api_url),
|
|
..site(ProviderKind::Github, None)
|
|
};
|
|
let client = ProviderClient::new(&site).unwrap();
|
|
|
|
let pr = client
|
|
.open_pull_request(
|
|
&EndpointConfig {
|
|
site: "github".to_string(),
|
|
kind: NamespaceKind::User,
|
|
namespace: "alice".to_string(),
|
|
},
|
|
&RemoteRepo {
|
|
name: "repo".to_string(),
|
|
clone_url: "https://github.com/alice/repo.git".to_string(),
|
|
private: true,
|
|
description: None,
|
|
},
|
|
&PullRequestRequest {
|
|
title: "Resolve conflict".to_string(),
|
|
body: "Body".to_string(),
|
|
head_branch: "git-sync/conflicts/main/from-b-abc123".to_string(),
|
|
base_branch: "main".to_string(),
|
|
},
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(pr.url.unwrap(), "https://github.example.test/pull/7");
|
|
handle.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn close_pull_requests_by_head_prefix_closes_matching_github_pulls() {
|
|
let (api_url, handle) = request_server(
|
|
vec![
|
|
(
|
|
"200 OK",
|
|
r#"[{"number":7,"head":{"ref":"git-sync/conflicts/main/from-b-abc123"}},{"number":8,"head":{"ref":"feature"}}]"#,
|
|
),
|
|
("200 OK", r#"{"number":7}"#),
|
|
],
|
|
|index, request| match index {
|
|
0 => assert!(
|
|
request
|
|
.starts_with("GET /repos/alice/repo/pulls?state=open&base=main&per_page=100 "),
|
|
"request was {request}"
|
|
),
|
|
1 => {
|
|
assert!(
|
|
request.starts_with("PATCH /repos/alice/repo/pulls/7 "),
|
|
"request was {request}"
|
|
);
|
|
assert!(request.contains("closed"));
|
|
}
|
|
_ => unreachable!(),
|
|
},
|
|
);
|
|
let site = SiteConfig {
|
|
api_url: Some(api_url),
|
|
..site(ProviderKind::Github, None)
|
|
};
|
|
let client = ProviderClient::new(&site).unwrap();
|
|
|
|
let closed = client
|
|
.close_pull_requests_by_head_prefix(
|
|
&EndpointConfig {
|
|
site: "github".to_string(),
|
|
kind: NamespaceKind::User,
|
|
namespace: "alice".to_string(),
|
|
},
|
|
&RemoteRepo {
|
|
name: "repo".to_string(),
|
|
clone_url: "https://github.com/alice/repo.git".to_string(),
|
|
private: true,
|
|
description: None,
|
|
},
|
|
"main",
|
|
"git-sync/conflicts/main/",
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(closed, 1);
|
|
handle.join().unwrap();
|
|
}
|
|
|
|
fn site(provider: ProviderKind, git_username: Option<String>) -> SiteConfig {
|
|
SiteConfig {
|
|
name: "site".to_string(),
|
|
provider,
|
|
base_url: "https://example.test".to_string(),
|
|
api_url: None,
|
|
token: TokenConfig::Value("secret".to_string()),
|
|
git_username,
|
|
}
|
|
}
|
|
|
|
fn one_request_server<F>(
|
|
status: &'static str,
|
|
body: &'static str,
|
|
assert_request: F,
|
|
) -> (String, thread::JoinHandle<()>)
|
|
where
|
|
F: FnOnce(&str) + Send + 'static,
|
|
{
|
|
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let address = listener.local_addr().unwrap();
|
|
let handle = thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
let mut buffer = [0_u8; 4096];
|
|
let bytes = stream.read(&mut buffer).unwrap();
|
|
let request = String::from_utf8_lossy(&buffer[..bytes]).to_string();
|
|
assert_request(&request);
|
|
|
|
write!(
|
|
stream,
|
|
"HTTP/1.1 {status}\r\ncontent-type: application/json\r\ncontent-length: {}\r\n\r\n{body}",
|
|
body.len()
|
|
)
|
|
.unwrap();
|
|
});
|
|
(format!("http://{address}"), handle)
|
|
}
|
|
|
|
fn request_server<F>(
|
|
responses: Vec<(&'static str, &'static str)>,
|
|
mut assert_request: F,
|
|
) -> (String, thread::JoinHandle<()>)
|
|
where
|
|
F: FnMut(usize, &str) + Send + 'static,
|
|
{
|
|
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
|
let address = listener.local_addr().unwrap();
|
|
let handle = thread::spawn(move || {
|
|
for (index, (status, body)) in responses.into_iter().enumerate() {
|
|
let (mut stream, _) = listener.accept().unwrap();
|
|
let mut buffer = [0_u8; 4096];
|
|
let bytes = stream.read(&mut buffer).unwrap();
|
|
let request = String::from_utf8_lossy(&buffer[..bytes]).to_string();
|
|
assert_request(index, &request);
|
|
|
|
write!(
|
|
stream,
|
|
"HTTP/1.1 {status}\r\ncontent-type: application/json\r\nconnection: close\r\ncontent-length: {}\r\n\r\n{body}",
|
|
body.len()
|
|
)
|
|
.unwrap();
|
|
}
|
|
});
|
|
(format!("http://{address}"), handle)
|
|
}
|