172b93d07f
* added common project information; setup for v2 test change * all tests now use with_test_environment * progress, failing * finished re-adding tests * prepare * cargo sqlx prepare -- --tests * fmt; clippy; prepare * sqlx prepare * adds version_create fix and corresponding test * merge fixes; rev * fmt, clippy, prepare * test cargo sqlx prepare
529 lines
21 KiB
Rust
529 lines
21 KiB
Rust
use crate::common::{
|
|
api_common::ApiProject,
|
|
api_v2::ApiV2,
|
|
database::{ENEMY_USER_PAT, FRIEND_USER_ID, FRIEND_USER_PAT, MOD_USER_PAT, USER_USER_PAT},
|
|
dummy_data::{TestFile, DUMMY_CATEGORIES},
|
|
environment::{with_test_environment, TestEnvironment},
|
|
permissions::{PermissionsTest, PermissionsTestContext},
|
|
};
|
|
use actix_web::test;
|
|
use itertools::Itertools;
|
|
use labrinth::{
|
|
database::models::project_item::PROJECTS_SLUGS_NAMESPACE,
|
|
models::teams::ProjectPermissions,
|
|
util::actix::{AppendsMultipart, MultipartSegment, MultipartSegmentData},
|
|
};
|
|
use serde_json::json;
|
|
|
|
#[actix_rt::test]
|
|
async fn test_project_type_sanity() {
|
|
with_test_environment(None, |test_env: TestEnvironment<ApiV2>| async move {
|
|
let api = &test_env.api;
|
|
|
|
// Perform all other patch tests on both 'mod' and 'modpack'
|
|
for (mod_or_modpack, slug, file) in [
|
|
("mod", "test-mod", TestFile::build_random_jar()),
|
|
("modpack", "test-modpack", TestFile::build_random_mrpack()),
|
|
] {
|
|
let (test_project, test_version) = api
|
|
.add_public_project(slug, Some(file), None, USER_USER_PAT)
|
|
.await;
|
|
let test_project_slug = test_project.slug.as_ref().unwrap();
|
|
|
|
// TODO:
|
|
// assert_eq!(test_project.project_type, mod_or_modpack);
|
|
assert_eq!(test_project.loaders, vec!["fabric"]);
|
|
assert_eq!(test_version[0].loaders, vec!["fabric"]);
|
|
|
|
let project = api
|
|
.get_project_deserialized(test_project_slug, USER_USER_PAT)
|
|
.await;
|
|
assert_eq!(test_project.loaders, vec!["fabric"]);
|
|
assert_eq!(project.project_type, mod_or_modpack);
|
|
|
|
let version = api
|
|
.get_version_deserialized(&test_version[0].id.to_string(), USER_USER_PAT)
|
|
.await;
|
|
assert_eq!(
|
|
version.loaders.iter().map(|x| &x.0).collect_vec(),
|
|
vec!["fabric"]
|
|
);
|
|
}
|
|
|
|
// TODO: as we get more complicated strucures with v3 testing, and alpha/beta get more complicated, we should add more tests here,
|
|
// to ensure that projects created with v3 routes are still valid and work with v3 routes.
|
|
})
|
|
.await;
|
|
}
|
|
|
|
#[actix_rt::test]
|
|
async fn test_add_remove_project() {
|
|
// Test setup and dummy data
|
|
with_test_environment(None, |test_env: TestEnvironment<ApiV2>| async move {
|
|
let api = &test_env.api;
|
|
|
|
// Generate test project data.
|
|
let mut json_data = json!(
|
|
{
|
|
"title": "Test_Add_Project project",
|
|
"slug": "demo",
|
|
"description": "Example description.",
|
|
"body": "Example body.",
|
|
"client_side": "required",
|
|
"server_side": "optional",
|
|
"initial_versions": [{
|
|
"file_parts": ["basic-mod.jar"],
|
|
"version_number": "1.2.3",
|
|
"version_title": "start",
|
|
"dependencies": [],
|
|
"game_versions": ["1.20.1"] ,
|
|
"release_channel": "release",
|
|
"loaders": ["fabric"],
|
|
"featured": true
|
|
}],
|
|
"categories": [],
|
|
"license_id": "MIT"
|
|
}
|
|
);
|
|
|
|
// Basic json
|
|
let json_segment = MultipartSegment {
|
|
name: "data".to_string(),
|
|
filename: None,
|
|
content_type: Some("application/json".to_string()),
|
|
data: MultipartSegmentData::Text(serde_json::to_string(&json_data).unwrap()),
|
|
};
|
|
|
|
// Basic json, with a different file
|
|
json_data["initial_versions"][0]["file_parts"][0] = json!("basic-mod-different.jar");
|
|
let json_diff_file_segment = MultipartSegment {
|
|
data: MultipartSegmentData::Text(serde_json::to_string(&json_data).unwrap()),
|
|
..json_segment.clone()
|
|
};
|
|
|
|
// Basic json, with a different file, and a different slug
|
|
json_data["slug"] = json!("new_demo");
|
|
json_data["initial_versions"][0]["file_parts"][0] = json!("basic-mod-different.jar");
|
|
let json_diff_slug_file_segment = MultipartSegment {
|
|
data: MultipartSegmentData::Text(serde_json::to_string(&json_data).unwrap()),
|
|
..json_segment.clone()
|
|
};
|
|
|
|
// Basic file
|
|
let file_segment = MultipartSegment {
|
|
name: "basic-mod.jar".to_string(),
|
|
filename: Some("basic-mod.jar".to_string()),
|
|
content_type: Some("application/java-archive".to_string()),
|
|
// TODO: look at these: can be simplified with TestFile
|
|
data: MultipartSegmentData::Binary(
|
|
include_bytes!("../../tests/files/basic-mod.jar").to_vec(),
|
|
),
|
|
};
|
|
|
|
// Differently named file, with the same content (for hash testing)
|
|
let file_diff_name_segment = MultipartSegment {
|
|
name: "basic-mod-different.jar".to_string(),
|
|
filename: Some("basic-mod-different.jar".to_string()),
|
|
content_type: Some("application/java-archive".to_string()),
|
|
data: MultipartSegmentData::Binary(
|
|
include_bytes!("../../tests/files/basic-mod.jar").to_vec(),
|
|
),
|
|
};
|
|
|
|
// Differently named file, with different content
|
|
let file_diff_name_content_segment = MultipartSegment {
|
|
name: "basic-mod-different.jar".to_string(),
|
|
filename: Some("basic-mod-different.jar".to_string()),
|
|
content_type: Some("application/java-archive".to_string()),
|
|
data: MultipartSegmentData::Binary(
|
|
include_bytes!("../../tests/files/basic-mod-different.jar").to_vec(),
|
|
),
|
|
};
|
|
|
|
// Add a project- simple, should work.
|
|
let req = test::TestRequest::post()
|
|
.uri("/v2/project")
|
|
.append_header(("Authorization", USER_USER_PAT))
|
|
.set_multipart(vec![json_segment.clone(), file_segment.clone()])
|
|
.to_request();
|
|
let resp = test_env.call(req).await;
|
|
|
|
let status = resp.status();
|
|
assert_eq!(status, 200);
|
|
|
|
// Get the project we just made, and confirm that it's correct
|
|
let project = api.get_project_deserialized("demo", USER_USER_PAT).await;
|
|
assert!(project.versions.len() == 1);
|
|
let uploaded_version_id = project.versions[0];
|
|
|
|
// Checks files to ensure they were uploaded and correctly identify the file
|
|
let hash = sha1::Sha1::from(include_bytes!("../../tests/files/basic-mod.jar"))
|
|
.digest()
|
|
.to_string();
|
|
let version = api
|
|
.get_version_from_hash_deserialized(&hash, "sha1", USER_USER_PAT)
|
|
.await;
|
|
assert_eq!(version.id, uploaded_version_id);
|
|
|
|
// Reusing with a different slug and the same file should fail
|
|
// Even if that file is named differently
|
|
let req = test::TestRequest::post()
|
|
.uri("/v2/project")
|
|
.append_header(("Authorization", USER_USER_PAT))
|
|
.set_multipart(vec![
|
|
json_diff_slug_file_segment.clone(), // Different slug, different file name
|
|
file_diff_name_segment.clone(), // Different file name, same content
|
|
])
|
|
.to_request();
|
|
|
|
let resp = test_env.call(req).await;
|
|
assert_eq!(resp.status(), 400);
|
|
|
|
// Reusing with the same slug and a different file should fail
|
|
let req = test::TestRequest::post()
|
|
.uri("/v2/project")
|
|
.append_header(("Authorization", USER_USER_PAT))
|
|
.set_multipart(vec![
|
|
json_diff_file_segment.clone(), // Same slug, different file name
|
|
file_diff_name_content_segment.clone(), // Different file name, different content
|
|
])
|
|
.to_request();
|
|
|
|
let resp = test_env.call(req).await;
|
|
assert_eq!(resp.status(), 400);
|
|
|
|
// Different slug, different file should succeed
|
|
let req = test::TestRequest::post()
|
|
.uri("/v2/project")
|
|
.append_header(("Authorization", USER_USER_PAT))
|
|
.set_multipart(vec![
|
|
json_diff_slug_file_segment.clone(), // Different slug, different file name
|
|
file_diff_name_content_segment.clone(), // Different file name, same content
|
|
])
|
|
.to_request();
|
|
|
|
let resp = test_env.call(req).await;
|
|
assert_eq!(resp.status(), 200);
|
|
|
|
// Get
|
|
let project = api.get_project_deserialized("demo", USER_USER_PAT).await;
|
|
let id = project.id.to_string();
|
|
|
|
// Remove the project
|
|
let resp = test_env.api.remove_project("demo", USER_USER_PAT).await;
|
|
assert_eq!(resp.status(), 204);
|
|
|
|
// Confirm that the project is gone from the cache
|
|
let mut redis_conn = test_env.db.redis_pool.connect().await.unwrap();
|
|
assert_eq!(
|
|
redis_conn
|
|
.get(PROJECTS_SLUGS_NAMESPACE, "demo")
|
|
.await
|
|
.unwrap()
|
|
.map(|x| x.parse::<i64>().unwrap()),
|
|
None
|
|
);
|
|
assert_eq!(
|
|
redis_conn
|
|
.get(PROJECTS_SLUGS_NAMESPACE, &id)
|
|
.await
|
|
.unwrap()
|
|
.map(|x| x.parse::<i64>().unwrap()),
|
|
None
|
|
);
|
|
|
|
// Old slug no longer works
|
|
let resp = api.get_project("demo", USER_USER_PAT).await;
|
|
assert_eq!(resp.status(), 404);
|
|
})
|
|
.await;
|
|
}
|
|
|
|
#[actix_rt::test]
|
|
async fn permissions_upload_version() {
|
|
with_test_environment(None, |test_env: TestEnvironment<ApiV2>| async move {
|
|
let alpha_project_id = &test_env.dummy.as_ref().unwrap().project_alpha.project_id;
|
|
let alpha_version_id = &test_env.dummy.as_ref().unwrap().project_alpha.version_id;
|
|
let alpha_team_id = &test_env.dummy.as_ref().unwrap().project_alpha.team_id;
|
|
let alpha_file_hash = &test_env.dummy.as_ref().unwrap().project_alpha.file_hash;
|
|
|
|
let upload_version = ProjectPermissions::UPLOAD_VERSION;
|
|
|
|
// Upload version with basic-mod.jar
|
|
let req_gen = |ctx: &PermissionsTestContext| {
|
|
test::TestRequest::post().uri("/v2/version").set_multipart([
|
|
MultipartSegment {
|
|
name: "data".to_string(),
|
|
filename: None,
|
|
content_type: Some("application/json".to_string()),
|
|
data: MultipartSegmentData::Text(
|
|
serde_json::to_string(&json!({
|
|
"project_id": ctx.project_id.unwrap(),
|
|
"file_parts": ["basic-mod.jar"],
|
|
"version_number": "1.0.0",
|
|
"version_title": "1.0.0",
|
|
"version_type": "release",
|
|
"dependencies": [],
|
|
"game_versions": ["1.20.1"],
|
|
"loaders": ["fabric"],
|
|
"featured": false,
|
|
|
|
}))
|
|
.unwrap(),
|
|
),
|
|
},
|
|
MultipartSegment {
|
|
name: "basic-mod.jar".to_string(),
|
|
filename: Some("basic-mod.jar".to_string()),
|
|
content_type: Some("application/java-archive".to_string()),
|
|
data: MultipartSegmentData::Binary(
|
|
include_bytes!("../../tests/files/basic-mod.jar").to_vec(),
|
|
),
|
|
},
|
|
])
|
|
};
|
|
PermissionsTest::new(&test_env)
|
|
.simple_project_permissions_test(upload_version, req_gen)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Upload file to existing version
|
|
// Uses alpha project, as it has an existing version
|
|
let req_gen = |_: &PermissionsTestContext| {
|
|
test::TestRequest::post()
|
|
.uri(&format!("/v2/version/{}/file", alpha_version_id))
|
|
.set_multipart([
|
|
MultipartSegment {
|
|
name: "data".to_string(),
|
|
filename: None,
|
|
content_type: Some("application/json".to_string()),
|
|
data: MultipartSegmentData::Text(
|
|
serde_json::to_string(&json!({
|
|
"file_parts": ["basic-mod-different.jar"],
|
|
}))
|
|
.unwrap(),
|
|
),
|
|
},
|
|
MultipartSegment {
|
|
name: "basic-mod-different.jar".to_string(),
|
|
filename: Some("basic-mod-different.jar".to_string()),
|
|
content_type: Some("application/java-archive".to_string()),
|
|
data: MultipartSegmentData::Binary(
|
|
include_bytes!("../../tests/files/basic-mod-different.jar").to_vec(),
|
|
),
|
|
},
|
|
])
|
|
};
|
|
PermissionsTest::new(&test_env)
|
|
.with_existing_project(alpha_project_id, alpha_team_id)
|
|
.with_user(FRIEND_USER_ID, FRIEND_USER_PAT, true)
|
|
.simple_project_permissions_test(upload_version, req_gen)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Patch version
|
|
// Uses alpha project, as it has an existing version
|
|
let req_gen = |_: &PermissionsTestContext| {
|
|
test::TestRequest::patch()
|
|
.uri(&format!("/v2/version/{}", alpha_version_id))
|
|
.set_json(json!({
|
|
"name": "Basic Mod",
|
|
}))
|
|
};
|
|
PermissionsTest::new(&test_env)
|
|
.with_existing_project(alpha_project_id, alpha_team_id)
|
|
.with_user(FRIEND_USER_ID, FRIEND_USER_PAT, true)
|
|
.simple_project_permissions_test(upload_version, req_gen)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Delete version file
|
|
// Uses alpha project, as it has an existing version
|
|
let delete_version = ProjectPermissions::DELETE_VERSION;
|
|
let req_gen = |_: &PermissionsTestContext| {
|
|
test::TestRequest::delete().uri(&format!("/v2/version_file/{}", alpha_file_hash))
|
|
};
|
|
|
|
PermissionsTest::new(&test_env)
|
|
.with_existing_project(alpha_project_id, alpha_team_id)
|
|
.with_user(FRIEND_USER_ID, FRIEND_USER_PAT, true)
|
|
.simple_project_permissions_test(delete_version, req_gen)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Delete version
|
|
// Uses alpha project, as it has an existing version
|
|
let req_gen = |_: &PermissionsTestContext| {
|
|
test::TestRequest::delete().uri(&format!("/v2/version/{}", alpha_version_id))
|
|
};
|
|
PermissionsTest::new(&test_env)
|
|
.with_existing_project(alpha_project_id, alpha_team_id)
|
|
.with_user(FRIEND_USER_ID, FRIEND_USER_PAT, true)
|
|
.simple_project_permissions_test(delete_version, req_gen)
|
|
.await
|
|
.unwrap();
|
|
})
|
|
.await;
|
|
}
|
|
|
|
#[actix_rt::test]
|
|
pub async fn test_patch_project() {
|
|
with_test_environment(None, |test_env: TestEnvironment<ApiV2>| async move {
|
|
let api = &test_env.api;
|
|
|
|
let alpha_project_slug = &test_env.dummy.as_ref().unwrap().project_alpha.project_slug;
|
|
let beta_project_slug = &test_env.dummy.as_ref().unwrap().project_beta.project_slug;
|
|
|
|
// First, we do some patch requests that should fail.
|
|
// Failure because the user is not authorized.
|
|
let resp = api
|
|
.edit_project(
|
|
alpha_project_slug,
|
|
json!({
|
|
"title": "Test_Add_Project project - test 1",
|
|
}),
|
|
ENEMY_USER_PAT,
|
|
)
|
|
.await;
|
|
assert_eq!(resp.status(), 401);
|
|
|
|
// Failure because we are setting URL fields to invalid urls.
|
|
for url_type in ["issues_url", "source_url", "wiki_url", "discord_url"] {
|
|
let resp = api
|
|
.edit_project(
|
|
alpha_project_slug,
|
|
json!({
|
|
url_type: "w.fake.url",
|
|
}),
|
|
USER_USER_PAT,
|
|
)
|
|
.await;
|
|
assert_eq!(resp.status(), 400);
|
|
}
|
|
|
|
// Failure because these are illegal requested statuses for a normal user.
|
|
for req in ["unknown", "processing", "withheld", "scheduled"] {
|
|
let resp = api
|
|
.edit_project(
|
|
alpha_project_slug,
|
|
json!({
|
|
"requested_status": req,
|
|
}),
|
|
USER_USER_PAT,
|
|
)
|
|
.await;
|
|
assert_eq!(resp.status(), 400);
|
|
}
|
|
|
|
// Failure because these should not be able to be set by a non-mod
|
|
for key in ["moderation_message", "moderation_message_body"] {
|
|
let resp = api
|
|
.edit_project(
|
|
alpha_project_slug,
|
|
json!({
|
|
key: "test",
|
|
}),
|
|
USER_USER_PAT,
|
|
)
|
|
.await;
|
|
assert_eq!(resp.status(), 401);
|
|
|
|
// (should work for a mod, though)
|
|
let resp = api
|
|
.edit_project(
|
|
alpha_project_slug,
|
|
json!({
|
|
key: "test",
|
|
}),
|
|
MOD_USER_PAT,
|
|
)
|
|
.await;
|
|
assert_eq!(resp.status(), 204);
|
|
}
|
|
|
|
// Failed patch to alpha slug:
|
|
// - slug collision with beta
|
|
// - too short slug
|
|
// - too long slug
|
|
// - not url safe slug
|
|
// - not url safe slug
|
|
for slug in [
|
|
beta_project_slug,
|
|
"a",
|
|
&"a".repeat(100),
|
|
"not url safe%&^!#$##!@#$%^&*()",
|
|
] {
|
|
let resp = api
|
|
.edit_project(
|
|
alpha_project_slug,
|
|
json!({
|
|
"slug": slug, // the other dummy project has this slug
|
|
}),
|
|
USER_USER_PAT,
|
|
)
|
|
.await;
|
|
assert_eq!(resp.status(), 400);
|
|
}
|
|
|
|
// Not allowed to directly set status, as 'beta_project_slug' (the other project) is "processing" and cannot have its status changed like this.
|
|
let resp = api
|
|
.edit_project(
|
|
beta_project_slug,
|
|
json!({
|
|
"status": "private"
|
|
}),
|
|
USER_USER_PAT,
|
|
)
|
|
.await;
|
|
assert_eq!(resp.status(), 401);
|
|
|
|
// Sucessful request to patch many fields.
|
|
let resp = api
|
|
.edit_project(
|
|
alpha_project_slug,
|
|
json!({
|
|
"slug": "newslug",
|
|
"title": "New successful title",
|
|
"description": "New successful description",
|
|
"body": "New successful body",
|
|
"categories": [DUMMY_CATEGORIES[0]],
|
|
"license_id": "MIT",
|
|
"issues_url": "https://github.com",
|
|
"discord_url": "https://discord.gg",
|
|
"wiki_url": "https://wiki.com",
|
|
"client_side": "optional",
|
|
"server_side": "required",
|
|
"donation_urls": [{
|
|
"id": "patreon",
|
|
"platform": "Patreon",
|
|
"url": "https://patreon.com"
|
|
}]
|
|
}),
|
|
USER_USER_PAT,
|
|
)
|
|
.await;
|
|
assert_eq!(resp.status(), 204);
|
|
|
|
// Old slug no longer works
|
|
let resp = api.get_project(alpha_project_slug, USER_USER_PAT).await;
|
|
assert_eq!(resp.status(), 404);
|
|
|
|
// New slug does work
|
|
let project = api.get_project_deserialized("newslug", USER_USER_PAT).await;
|
|
|
|
assert_eq!(project.slug.unwrap(), "newslug");
|
|
assert_eq!(project.title, "New successful title");
|
|
assert_eq!(project.description, "New successful description");
|
|
assert_eq!(project.body, "New successful body");
|
|
assert_eq!(project.categories, vec![DUMMY_CATEGORIES[0]]);
|
|
assert_eq!(project.license.id, "MIT");
|
|
assert_eq!(project.issues_url, Some("https://github.com".to_string()));
|
|
assert_eq!(project.discord_url, Some("https://discord.gg".to_string()));
|
|
assert_eq!(project.wiki_url, Some("https://wiki.com".to_string()));
|
|
assert_eq!(project.client_side.as_str(), "optional");
|
|
assert_eq!(project.server_side.as_str(), "required");
|
|
assert_eq!(project.donation_urls.unwrap()[0].url, "https://patreon.com");
|
|
})
|
|
.await;
|
|
}
|