AxTps/Starlight_Lancher
2
2
Fork 1
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

feat：移除了弹窗，服务器添加sls

Browse Source
This commit is contained in:
Ap_Tx
2026-09-08 22:39:45 +08:00
commit 6a295f9a7a
4082 changed files with 1322534 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

815
packages/modrinth-content-management/tests/install.rs Normal file
View File

@ -0,0 +1,815 @@
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use async_trait::async_trait;
use chrono::{DateTime, Utc};
use modrinth_content_management::{
ContentMetadataProvider, ContentType, Dependency, DependencyType,
Error, ResolutionPreferences, ResolveContentRequest, SkippedReason,
Version, resolve_content,
};
const QUILT_FABRIC_API_EXCEPTION_PROJECT_ID: &str = "P7dR8mSH";
#[derive(Default)]
struct MemoryProvider {
versions: HashMap<String, Version>,
project_versions: HashMap<String, Vec<String>>,
}
#[async_trait]
impl ContentMetadataProvider for MemoryProvider {
async fn get_version(
&mut self,
version_id: &str,
) -> Result<Option<Version>, Error> {
Ok(self.versions.get(version_id).cloned())
}
async fn get_project_versions(
&mut self,
project_id: &str,
) -> Result<Vec<Version>, Error> {
Ok(self
.project_versions
.get(project_id)
.into_iter()
.flatten()
.filter_map(|id| self.versions.get(id))
.cloned()
.collect())
}
}
impl MemoryProvider {
fn with_versions(mut self, versions: Vec<Version>) -> Self {
for version in versions {
self.project_versions
.entry(version.project_id.clone())
.or_default()
.push(version.id.clone());
self.versions.insert(version.id.clone(), version);
}
self
}
fn with_project_versions(
mut self,
project_id: &str,
version_ids: &[&str],
) -> Self {
self.project_versions.insert(
project_id.to_string(),
version_ids.iter().map(|id| id.to_string()).collect(),
);
self
}
}
fn version(
id: &str,
project_id: &str,
date: &str,
game_versions: &[&str],
loaders: &[&str],
dependencies: Vec<Dependency>,
) -> Version {
version_with_channel(
id,
project_id,
date,
"release",
game_versions,
loaders,
dependencies,
)
}
fn version_with_channel(
id: &str,
project_id: &str,
date: &str,
version_type: &str,
game_versions: &[&str],
loaders: &[&str],
dependencies: Vec<Dependency>,
) -> Version {
Version {
id: id.to_string(),
project_id: project_id.to_string(),
date_published: DateTime::parse_from_rfc3339(date)
.unwrap()
.with_timezone(&Utc),
version_type: version_type.to_string(),
dependencies,
game_versions: game_versions
.iter()
.map(|v| v.to_string())
.collect(),
loaders: loaders.iter().map(|v| v.to_string()).collect(),
}
}
fn dependency(
project_id: Option<&str>,
version_id: Option<&str>,
dependency_type: DependencyType,
) -> Dependency {
Dependency {
version_id: version_id.map(str::to_string),
project_id: project_id.map(str::to_string),
file_name: None,
dependency_type,
}
}
fn required_project_dependency(project_id: &str) -> Dependency {
dependency(Some(project_id), None, DependencyType::Required)
}
fn required_version_dependency(version_id: &str) -> Dependency {
dependency(None, Some(version_id), DependencyType::Required)
}
fn request(project_id: &str) -> ResolveContentRequest {
ResolveContentRequest {
project_id: project_id.to_string(),
version_id: None,
content_type: ContentType::Mod,
selected: ResolutionPreferences::default(),
target: ResolutionPreferences {
game_versions: vec!["1.20.1".to_string()],
loaders: vec!["fabric".to_string()],
},
existing_project_ids: Vec::new(),
excluded_project_ids: Vec::new(),
force_project_ids: Vec::new(),
}
}
#[tokio::test]
async fn explicit_primary_version_is_used() {
let provider = MemoryProvider::default().with_versions(vec![version(
"v1",
"p1",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![],
)]);
let mut request = request("p1");
request.version_id = Some("v1".to_string());
let plan = resolve_content(provider, request).await.unwrap();
assert_eq!(plan.primary.version_id, "v1");
}
#[tokio::test]
async fn explicit_primary_version_bypasses_target_filters() {
let provider = MemoryProvider::default().with_versions(vec![version(
"v1",
"p1",
"2024-01-01T00:00:00Z",
&["1.21.1"],
&["neoforge"],
vec![],
)]);
let mut request = request("p1");
request.version_id = Some("v1".to_string());
let plan = resolve_content(provider, request).await.unwrap();
assert_eq!(plan.primary.version_id, "v1");
}
#[tokio::test]
async fn newest_matching_primary_version_is_selected() {
let provider = MemoryProvider::default().with_versions(vec![
version(
"old",
"p1",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![],
),
version(
"new",
"p1",
"2024-02-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![],
),
]);
let plan = resolve_content(provider, request("p1")).await.unwrap();
assert_eq!(plan.primary.version_id, "new");
}
#[tokio::test]
async fn automatic_primary_prefers_a_release_over_a_newer_beta() {
let provider = MemoryProvider::default().with_versions(vec![
version_with_channel(
"iris-release",
"iris",
"2026-05-01T00:00:00Z",
"release",
&["1.21.1"],
&["neoforge"],
vec![dependency(
Some("sodium"),
Some("sodium-release"),
DependencyType::Required,
)],
),
version_with_channel(
"iris-newer-beta",
"iris",
"2026-06-01T00:00:00Z",
"beta",
&["1.21.1"],
&["neoforge"],
vec![],
),
version_with_channel(
"sodium-release",
"sodium",
"2026-04-01T00:00:00Z",
"release",
&["1.21.1"],
&["neoforge"],
vec![],
),
]);
let mut install_request = request("iris");
install_request.target.game_versions = vec!["1.21.1".to_string()];
install_request.target.loaders = vec!["neoforge".to_string()];
let plan = resolve_content(provider, install_request).await.unwrap();
assert_eq!(plan.primary.version_id, "iris-release");
assert_eq!(plan.dependencies.len(), 1);
assert_eq!(plan.dependencies[0].version_id, "sodium-release");
}
#[tokio::test]
async fn project_only_dependency_uses_the_target_runtime() {
let provider = MemoryProvider::default().with_versions(vec![
version_with_channel(
"primary",
"primary",
"2026-06-01T00:00:00Z",
"release",
&["1.21.1"],
&["neoforge"],
vec![required_project_dependency("dependency")],
),
version_with_channel(
"wrong-game-version",
"dependency",
"2026-07-01T00:00:00Z",
"beta",
&["1.21.2"],
&["neoforge"],
vec![],
),
version_with_channel(
"wrong-loader",
"dependency",
"2026-06-15T00:00:00Z",
"beta",
&["1.21.1"],
&["fabric"],
vec![],
),
version_with_channel(
"matching-runtime",
"dependency",
"2026-05-01T00:00:00Z",
"release",
&["1.21.1"],
&["neoforge"],
vec![],
),
]);
let mut install_request = request("primary");
install_request.version_id = Some("primary".to_string());
install_request.target.game_versions = vec!["1.21.1".to_string()];
install_request.target.loaders = vec!["neoforge".to_string()];
let plan = resolve_content(provider, install_request).await.unwrap();
assert_eq!(plan.primary.version_id, "primary");
assert_eq!(plan.dependencies.len(), 1);
assert_eq!(plan.dependencies[0].version_id, "matching-runtime");
}
#[tokio::test]
async fn project_only_dependency_selects_matching_version() {
let provider = MemoryProvider::default().with_versions(vec![
version(
"p1v1",
"p1",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![required_project_dependency("dep")],
),
version(
"depv1",
"dep",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![],
),
]);
let plan = resolve_content(provider, request("p1")).await.unwrap();
assert_eq!(plan.dependencies[0].project_id, "dep");
assert_eq!(
plan.dependencies[0].dependent_on_version_id.as_deref(),
Some("p1v1")
);
}
#[tokio::test]
async fn exact_version_dependency_bypasses_target_filters() {
let provider = MemoryProvider::default().with_versions(vec![
version(
"p1v1",
"p1",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![required_version_dependency("depv1")],
),
version(
"depv1",
"dep",
"2024-01-01T00:00:00Z",
&["1.19.4"],
&["forge"],
vec![],
),
]);
let plan = resolve_content(provider, request("p1")).await.unwrap();
assert_eq!(plan.dependencies.len(), 1);
assert_eq!(plan.dependencies[0].project_id, "dep");
assert_eq!(plan.dependencies[0].version_id, "depv1");
assert!(plan.skipped.is_empty());
}
#[tokio::test]
async fn already_installed_dependencies_are_skipped() {
let provider = MemoryProvider::default().with_versions(vec![
version(
"p1v1",
"p1",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![required_project_dependency("dep")],
),
version(
"depv1",
"dep",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![],
),
]);
let mut request = request("p1");
request.existing_project_ids = vec!["dep".to_string()];
let plan = resolve_content(provider, request).await.unwrap();
assert!(plan.dependencies.is_empty());
assert_eq!(plan.skipped[0].reason, SkippedReason::AlreadyInstalled);
}
#[tokio::test]
async fn duplicate_dependency_projects_are_skipped() {
let provider = MemoryProvider::default().with_versions(vec![
version(
"p1v1",
"p1",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![
required_project_dependency("dep"),
required_project_dependency("dep"),
],
),
version(
"depv1",
"dep",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![],
),
]);
let plan = resolve_content(provider, request("p1")).await.unwrap();
assert_eq!(plan.dependencies.len(), 1);
assert_eq!(plan.skipped[0].reason, SkippedReason::DuplicateProject);
}
#[tokio::test]
async fn conflicting_dependency_versions_are_skipped() {
let provider = MemoryProvider::default().with_versions(vec![
version(
"p1v1",
"p1",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![
dependency(
Some("dep"),
Some("depv1"),
DependencyType::Required,
),
dependency(
Some("dep"),
Some("depv2"),
DependencyType::Required,
),
],
),
version(
"depv1",
"dep",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![],
),
version(
"depv2",
"dep",
"2024-02-01T00:00:00Z",
&["1.20.1"],
&["fabric"],
vec![],
),
]);
let plan = resolve_content(provider, request("p1")).await.unwrap();
assert_eq!(plan.dependencies.len(), 1);
assert_eq!(
plan.skipped[0].reason,
SkippedReason::ConflictingDependency
);
}
#[tokio::test]
async fn quilt_instances_replace_fabric_api_with_quilted_fabric_api() {
let provider = MemoryProvider::default().with_versions(vec![
version(
"p1v1",
"p1",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["quilt"],
vec![required_project_dependency(
QUILT_FABRIC_API_EXCEPTION_PROJECT_ID,
)],
),
version(
"qfabv1",
"qvIfYCYJ",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["quilt"],
vec![],
),
]);
let mut request = request("p1");
request.target.loaders = vec!["quilt".to_string()];
let plan = resolve_content(provider, request).await.unwrap();
assert_eq!(plan.dependencies.len(), 1);
assert_eq!(plan.dependencies[0].project_id, "qvIfYCYJ");
assert!(plan.skipped.is_empty());
}
#[tokio::test]
async fn iris_metadata_gap_injects_missing_sodium_dependency() {
let provider = MemoryProvider::default().with_versions(vec![
version(
"Cjwm9s3i",
"YL57xq9U",
"2023-12-13T02:48:08Z",
&["1.20.2"],
&["fabric"],
vec![],
),
version(
"pmgeU5yX",
"AANobbMI",
"2023-12-09T04:07:46Z",
&["1.20.2"],
&["fabric"],
vec![],
),
]);
let mut request = request("YL57xq9U");
request.target.game_versions = vec!["1.20.2".to_string()];
let plan = resolve_content(provider, request).await.unwrap();
assert_eq!(plan.dependencies.len(), 1);
assert_eq!(plan.dependencies[0].project_id, "AANobbMI");
assert_eq!(plan.dependencies[0].version_id, "pmgeU5yX");
assert!(plan.skipped.is_empty());
}
#[tokio::test]
async fn iris_metadata_gap_is_not_duplicated_once_upstream_is_fixed() {
let provider = MemoryProvider::default().with_versions(vec![
version(
"Cjwm9s3i",
"YL57xq9U",
"2023-12-13T02:48:08Z",
&["1.20.2"],
&["fabric"],
vec![required_project_dependency("AANobbMI")],
),
version(
"pmgeU5yX",
"AANobbMI",
"2023-12-09T04:07:46Z",
&["1.20.2"],
&["fabric"],
vec![],
),
]);
let mut request = request("YL57xq9U");
request.target.game_versions = vec!["1.20.2".to_string()];
let plan = resolve_content(provider, request).await.unwrap();
assert_eq!(plan.dependencies.len(), 1);
assert_eq!(plan.dependencies[0].version_id, "pmgeU5yX");
assert!(plan.skipped.is_empty());
}
#[tokio::test]
async fn iris_metadata_gap_does_not_apply_to_other_versions() {
let provider = MemoryProvider::default().with_versions(vec![version(
"other",
"YL57xq9U",
"2024-01-01T00:00:00Z",
&["1.20.2"],
&["fabric"],
vec![],
)]);
let mut request = request("YL57xq9U");
request.target.game_versions = vec!["1.20.2".to_string()];
let plan = resolve_content(provider, request).await.unwrap();
assert!(plan.dependencies.is_empty());
assert!(plan.skipped.is_empty());
}
#[tokio::test]
async fn mods_reject_datapack_versions_when_a_loader_is_requested() {
let provider = MemoryProvider::default().with_versions(vec![version(
"p1v1",
"p1",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["datapack"],
vec![],
)]);
assert!(matches!(
resolve_content(provider, request("p1")).await,
Err(Error::NoCompatibleVersion(project_id)) if project_id == "p1"
));
}
#[tokio::test]
async fn neoforge_rejects_neo_loader_alias() {
let provider = MemoryProvider::default().with_versions(vec![version(
"p1v1",
"p1",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["neo"],
vec![],
)]);
let mut request = request("p1");
request.target.loaders = vec!["neoforge".to_string()];
assert!(matches!(
resolve_content(provider, request).await,
Err(Error::NoCompatibleVersion(project_id)) if project_id == "p1"
));
}
#[tokio::test]
async fn paper_rejects_bukkit_loader_alias() {
let provider = MemoryProvider::default().with_versions(vec![version(
"p1v1",
"p1",
"2024-01-01T00:00:00Z",
&["1.20.1"],
&["bukkit"],
vec![],
)]);
let mut request = request("p1");
request.content_type = ContentType::Plugin;
request.target.loaders = vec!["paper".to_string()];
assert!(matches!(
resolve_content(provider, request).await,
Err(Error::NoCompatibleVersion(project_id)) if project_id == "p1"
));
}
#[tokio::test]
async fn modpack_embedded_dependencies_are_not_installed() {
let provider = MemoryProvider::default()
.with_versions(vec![version(
"Ur9uoHH5",
"shFhR8Vx",
"2025-01-19T06:39:41.349487Z",
&["1.20.1"],
&["fabric"],
vec![
dependency(
Some("embedded-a"),
None,
DependencyType::Embedded,
),
dependency(
Some("embedded-b"),
None,
DependencyType::Embedded,
),
dependency(
Some("embedded-c"),
None,
DependencyType::Embedded,
),
],
)])
.with_project_versions("better-mc-fabric-bmc2", &["Ur9uoHH5"]);
let plan = resolve_content(
provider,
ResolveContentRequest {
project_id: "better-mc-fabric-bmc2".to_string(),
version_id: None,
content_type: ContentType::ModPack,
selected: ResolutionPreferences::default(),
target: ResolutionPreferences::default(),
existing_project_ids: Vec::new(),
excluded_project_ids: Vec::new(),
force_project_ids: Vec::new(),
},
)
.await
.unwrap();
assert_eq!(plan.primary.project_id, "shFhR8Vx");
assert_eq!(plan.primary.version_id, "Ur9uoHH5");
assert!(plan.dependencies.is_empty());
assert!(plan.skipped.is_empty());
}
#[tokio::test]
async fn required_dependencies_resolve_transitively() {
let provider = MemoryProvider::default().with_versions(vec![
version(
"pKFEfjEB",
"DdAlVT8M",
"2026-06-07T21:21:24.772638Z",
&["1.21.1", "1.21.2"],
&["neoforge"],
vec![
dependency(
Some("LNytGWDc"),
Some("UjX6dr61"),
DependencyType::Required,
),
dependency(
Some("oWaK0Q19"),
Some("YhZLrAFC"),
DependencyType::Required,
),
],
),
version(
"UjX6dr61",
"LNytGWDc",
"2026-04-21T22:20:03.579201Z",
&["1.21.1"],
&["neoforge"],
vec![],
),
version(
"YhZLrAFC",
"oWaK0Q19",
"2026-05-21T22:20:03.579201Z",
&["1.21.1"],
&["neoforge"],
vec![
dependency(
Some("T9PomCSv"),
None,
DependencyType::Required,
),
dependency(
Some("LNytGWDc"),
Some("UjX6dr61"),
DependencyType::Required,
),
],
),
version(
"hyQUls27",
"T9PomCSv",
"2026-06-17T04:32:50.469591Z",
&["1.21.1"],
&["fabric"],
vec![],
),
version(
"1L6XJqnY",
"T9PomCSv",
"2026-06-17T04:32:49.279302Z",
&["1.21.1"],
&["neoforge"],
vec![],
),
]);
let plan = resolve_content(
provider,
ResolveContentRequest {
project_id: "DdAlVT8M".to_string(),
version_id: Some("pKFEfjEB".to_string()),
content_type: ContentType::Mod,
selected: ResolutionPreferences::default(),
target: ResolutionPreferences {
game_versions: vec![
"1.21.1".to_string(),
"1.21.2".to_string(),
],
loaders: vec!["neoforge".to_string()],
},
existing_project_ids: Vec::new(),
excluded_project_ids: Vec::new(),
force_project_ids: Vec::new(),
},
)
.await
.unwrap();
assert_eq!(plan.primary.project_id, "DdAlVT8M");
assert_eq!(plan.primary.version_id, "pKFEfjEB");
assert_eq!(plan.dependencies.len(), 3);
assert!(plan.dependencies.iter().any(|dependency| {
dependency.project_id == "LNytGWDc"
&& dependency.version_id == "UjX6dr61"
&& dependency.dependent_on_version_id.as_deref()
== Some("pKFEfjEB")
}));
assert!(plan.dependencies.iter().any(|dependency| {
dependency.project_id == "oWaK0Q19"
&& dependency.version_id == "YhZLrAFC"
&& dependency.dependent_on_version_id.as_deref()
== Some("pKFEfjEB")
}));
assert!(plan.dependencies.iter().any(|dependency| {
dependency.project_id == "T9PomCSv"
&& dependency.version_id == "1L6XJqnY"
&& dependency.dependent_on_version_id.as_deref()
== Some("YhZLrAFC")
}));
assert_eq!(plan.skipped.len(), 1);
assert_eq!(
plan.skipped[0].reason,
modrinth_content_management::SkippedReason::DuplicateProject
);
assert_eq!(plan.skipped[0].project_id, "LNytGWDc");
}
}