74973e73e6
* moved files * moved files * initial v3 additions * moves req data * tests passing, restructuring, remove v2 * fmt; clippy; prepare * merge conflicts + issues * merge conflict, fmt, clippy, prepare * revs * fixed failing test * fixed tests
423 lines
13 KiB
Rust
423 lines
13 KiB
Rust
use std::collections::HashMap;
|
|
|
|
use actix_http::{header::AUTHORIZATION, StatusCode};
|
|
use actix_web::{
|
|
dev::ServiceResponse,
|
|
test::{self, TestRequest},
|
|
};
|
|
use labrinth::{
|
|
models::{projects::VersionType, v3::projects::Version},
|
|
routes::v3::version_file::FileUpdateData,
|
|
util::actix::AppendsMultipart,
|
|
};
|
|
use serde_json::json;
|
|
|
|
use crate::common::asserts::assert_status;
|
|
|
|
use super::{request_data::VersionCreationRequestData, ApiV3};
|
|
|
|
pub fn url_encode_json_serialized_vec(elements: &[String]) -> String {
|
|
let serialized = serde_json::to_string(&elements).unwrap();
|
|
urlencoding::encode(&serialized).to_string()
|
|
}
|
|
|
|
impl ApiV3 {
|
|
pub async fn add_public_version(
|
|
&self,
|
|
creation_data: VersionCreationRequestData,
|
|
pat: &str,
|
|
) -> ServiceResponse {
|
|
// Add a project.
|
|
let req = TestRequest::post()
|
|
.uri("/v3/version")
|
|
.append_header(("Authorization", pat))
|
|
.set_multipart(creation_data.segment_data)
|
|
.to_request();
|
|
self.call(req).await
|
|
}
|
|
|
|
pub async fn add_public_version_deserialized(
|
|
&self,
|
|
creation_data: VersionCreationRequestData,
|
|
pat: &str,
|
|
) -> Version {
|
|
let resp = self.add_public_version(creation_data, pat).await;
|
|
assert_status(&resp, StatusCode::OK);
|
|
let value: serde_json::Value = test::read_body_json(resp).await;
|
|
let version_id = value["id"].as_str().unwrap();
|
|
self.get_version_deserialized(version_id, pat).await
|
|
}
|
|
|
|
pub async fn get_version(&self, id: &str, pat: &str) -> ServiceResponse {
|
|
let req = TestRequest::get()
|
|
.uri(&format!("/v3/version/{id}"))
|
|
.append_header(("Authorization", pat))
|
|
.to_request();
|
|
self.call(req).await
|
|
}
|
|
|
|
pub async fn get_version_deserialized(&self, id: &str, pat: &str) -> Version {
|
|
let resp = self.get_version(id, pat).await;
|
|
assert_eq!(resp.status(), 200);
|
|
test::read_body_json(resp).await
|
|
}
|
|
|
|
pub async fn edit_version(
|
|
&self,
|
|
version_id: &str,
|
|
patch: serde_json::Value,
|
|
pat: &str,
|
|
) -> ServiceResponse {
|
|
let req = test::TestRequest::patch()
|
|
.uri(&format!("/v3/version/{version_id}"))
|
|
.append_header(("Authorization", pat))
|
|
.set_json(patch)
|
|
.to_request();
|
|
|
|
self.call(req).await
|
|
}
|
|
|
|
pub async fn get_version_from_hash(
|
|
&self,
|
|
hash: &str,
|
|
algorithm: &str,
|
|
pat: &str,
|
|
) -> ServiceResponse {
|
|
let req = test::TestRequest::get()
|
|
.uri(&format!("/v3/version_file/{hash}?algorithm={algorithm}"))
|
|
.append_header(("Authorization", pat))
|
|
.to_request();
|
|
self.call(req).await
|
|
}
|
|
|
|
pub async fn get_version_from_hash_deserialized(
|
|
&self,
|
|
hash: &str,
|
|
algorithm: &str,
|
|
pat: &str,
|
|
) -> Version {
|
|
let resp = self.get_version_from_hash(hash, algorithm, pat).await;
|
|
assert_eq!(resp.status(), 200);
|
|
test::read_body_json(resp).await
|
|
}
|
|
|
|
pub async fn get_versions_from_hashes(
|
|
&self,
|
|
hashes: &[&str],
|
|
algorithm: &str,
|
|
pat: &str,
|
|
) -> ServiceResponse {
|
|
let req = TestRequest::post()
|
|
.uri("/v3/version_files")
|
|
.append_header(("Authorization", pat))
|
|
.set_json(json!({
|
|
"hashes": hashes,
|
|
"algorithm": algorithm,
|
|
}))
|
|
.to_request();
|
|
self.call(req).await
|
|
}
|
|
|
|
pub async fn get_versions_from_hashes_deserialized(
|
|
&self,
|
|
hashes: &[&str],
|
|
algorithm: &str,
|
|
pat: &str,
|
|
) -> HashMap<String, Version> {
|
|
let resp = self.get_versions_from_hashes(hashes, algorithm, pat).await;
|
|
assert_eq!(resp.status(), 200);
|
|
test::read_body_json(resp).await
|
|
}
|
|
|
|
pub async fn get_update_from_hash(
|
|
&self,
|
|
hash: &str,
|
|
algorithm: &str,
|
|
loaders: Option<Vec<String>>,
|
|
game_versions: Option<Vec<String>>,
|
|
version_types: Option<Vec<String>>,
|
|
pat: &str,
|
|
) -> ServiceResponse {
|
|
let mut json = json!({});
|
|
if let Some(loaders) = loaders {
|
|
json["loaders"] = serde_json::to_value(loaders).unwrap();
|
|
}
|
|
if let Some(game_versions) = game_versions {
|
|
json["loader_fields"] = json!({
|
|
"game_versions": game_versions,
|
|
});
|
|
}
|
|
if let Some(version_types) = version_types {
|
|
json["version_types"] = serde_json::to_value(version_types).unwrap();
|
|
}
|
|
|
|
let req = test::TestRequest::post()
|
|
.uri(&format!(
|
|
"/v3/version_file/{hash}/update?algorithm={algorithm}"
|
|
))
|
|
.append_header(("Authorization", pat))
|
|
.set_json(json)
|
|
.to_request();
|
|
self.call(req).await
|
|
}
|
|
|
|
pub async fn get_update_from_hash_deserialized(
|
|
&self,
|
|
hash: &str,
|
|
algorithm: &str,
|
|
loaders: Option<Vec<String>>,
|
|
game_versions: Option<Vec<String>>,
|
|
version_types: Option<Vec<String>>,
|
|
pat: &str,
|
|
) -> Version {
|
|
let resp = self
|
|
.get_update_from_hash(hash, algorithm, loaders, game_versions, version_types, pat)
|
|
.await;
|
|
assert_eq!(resp.status(), 200);
|
|
test::read_body_json(resp).await
|
|
}
|
|
|
|
pub async fn update_files(
|
|
&self,
|
|
algorithm: &str,
|
|
hashes: Vec<String>,
|
|
loaders: Option<Vec<String>>,
|
|
game_versions: Option<Vec<String>>,
|
|
version_types: Option<Vec<String>>,
|
|
pat: &str,
|
|
) -> ServiceResponse {
|
|
let mut json = json!({
|
|
"algorithm": algorithm,
|
|
"hashes": hashes,
|
|
});
|
|
if let Some(loaders) = loaders {
|
|
json["loaders"] = serde_json::to_value(loaders).unwrap();
|
|
}
|
|
if let Some(game_versions) = game_versions {
|
|
json["loader_fields"] = json!({
|
|
"game_versions": game_versions,
|
|
});
|
|
}
|
|
if let Some(version_types) = version_types {
|
|
json["version_types"] = serde_json::to_value(version_types).unwrap();
|
|
}
|
|
|
|
let req = test::TestRequest::post()
|
|
.uri("/v3/version_files/update")
|
|
.append_header(("Authorization", pat))
|
|
.set_json(json)
|
|
.to_request();
|
|
self.call(req).await
|
|
}
|
|
|
|
pub async fn update_files_deserialized(
|
|
&self,
|
|
algorithm: &str,
|
|
hashes: Vec<String>,
|
|
loaders: Option<Vec<String>>,
|
|
game_versions: Option<Vec<String>>,
|
|
version_types: Option<Vec<String>>,
|
|
pat: &str,
|
|
) -> HashMap<String, Version> {
|
|
let resp = self
|
|
.update_files(
|
|
algorithm,
|
|
hashes,
|
|
loaders,
|
|
game_versions,
|
|
version_types,
|
|
pat,
|
|
)
|
|
.await;
|
|
assert_eq!(resp.status(), 200);
|
|
test::read_body_json(resp).await
|
|
}
|
|
|
|
pub async fn update_individual_files(
|
|
&self,
|
|
algorithm: &str,
|
|
hashes: Vec<FileUpdateData>,
|
|
pat: &str,
|
|
) -> ServiceResponse {
|
|
let req = test::TestRequest::post()
|
|
.uri("/v3/version_files/update_individual")
|
|
.append_header(("Authorization", pat))
|
|
.set_json(json!({
|
|
"algorithm": algorithm,
|
|
"hashes": hashes
|
|
}))
|
|
.to_request();
|
|
self.call(req).await
|
|
}
|
|
|
|
pub async fn update_individual_files_deserialized(
|
|
&self,
|
|
algorithm: &str,
|
|
hashes: Vec<FileUpdateData>,
|
|
pat: &str,
|
|
) -> HashMap<String, Version> {
|
|
let resp = self.update_individual_files(algorithm, hashes, pat).await;
|
|
assert_eq!(resp.status(), 200);
|
|
test::read_body_json(resp).await
|
|
}
|
|
|
|
// TODO: Not all fields are tested currently in the v3 tests, only the v2-v3 relevant ones are
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub async fn get_project_versions(
|
|
&self,
|
|
project_id_slug: &str,
|
|
game_versions: Option<Vec<String>>,
|
|
loaders: Option<Vec<String>>,
|
|
featured: Option<bool>,
|
|
version_type: Option<VersionType>,
|
|
limit: Option<usize>,
|
|
offset: Option<usize>,
|
|
pat: &str,
|
|
) -> ServiceResponse {
|
|
let mut query_string = String::new();
|
|
if let Some(game_versions) = game_versions {
|
|
query_string.push_str(&format!(
|
|
"&game_versions={}",
|
|
urlencoding::encode(&serde_json::to_string(&game_versions).unwrap())
|
|
));
|
|
}
|
|
if let Some(loaders) = loaders {
|
|
query_string.push_str(&format!(
|
|
"&loaders={}",
|
|
urlencoding::encode(&serde_json::to_string(&loaders).unwrap())
|
|
));
|
|
}
|
|
if let Some(featured) = featured {
|
|
query_string.push_str(&format!("&featured={}", featured));
|
|
}
|
|
if let Some(version_type) = version_type {
|
|
query_string.push_str(&format!("&version_type={}", version_type));
|
|
}
|
|
if let Some(limit) = limit {
|
|
let limit = limit.to_string();
|
|
query_string.push_str(&format!("&limit={}", limit));
|
|
}
|
|
if let Some(offset) = offset {
|
|
let offset = offset.to_string();
|
|
query_string.push_str(&format!("&offset={}", offset));
|
|
}
|
|
|
|
let req = test::TestRequest::get()
|
|
.uri(&format!(
|
|
"/v3/project/{project_id_slug}/version?{}",
|
|
query_string.trim_start_matches('&')
|
|
))
|
|
.append_header(("Authorization", pat))
|
|
.to_request();
|
|
self.call(req).await
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub async fn get_project_versions_deserialized(
|
|
&self,
|
|
slug: &str,
|
|
game_versions: Option<Vec<String>>,
|
|
loaders: Option<Vec<String>>,
|
|
featured: Option<bool>,
|
|
version_type: Option<VersionType>,
|
|
limit: Option<usize>,
|
|
offset: Option<usize>,
|
|
pat: &str,
|
|
) -> Vec<Version> {
|
|
let resp = self
|
|
.get_project_versions(
|
|
slug,
|
|
game_versions,
|
|
loaders,
|
|
featured,
|
|
version_type,
|
|
limit,
|
|
offset,
|
|
pat,
|
|
)
|
|
.await;
|
|
assert_eq!(resp.status(), 200);
|
|
test::read_body_json(resp).await
|
|
}
|
|
|
|
// TODO: remove redundancy in these functions
|
|
|
|
pub async fn create_default_version(
|
|
&self,
|
|
project_id: &str,
|
|
ordering: Option<i32>,
|
|
pat: &str,
|
|
) -> Version {
|
|
let json_data = json!(
|
|
{
|
|
"project_id": project_id,
|
|
"file_parts": ["basic-mod-different.jar"],
|
|
"version_number": "1.2.3.4",
|
|
"version_title": "start",
|
|
"dependencies": [],
|
|
"game_versions": ["1.20.1"] ,
|
|
"client_side": "required",
|
|
"server_side": "optional",
|
|
"release_channel": "release",
|
|
"loaders": ["fabric"],
|
|
"featured": true,
|
|
"ordering": ordering,
|
|
}
|
|
);
|
|
let json_segment = labrinth::util::actix::MultipartSegment {
|
|
name: "data".to_string(),
|
|
filename: None,
|
|
content_type: Some("application/json".to_string()),
|
|
data: labrinth::util::actix::MultipartSegmentData::Text(
|
|
serde_json::to_string(&json_data).unwrap(),
|
|
),
|
|
};
|
|
let file_segment = labrinth::util::actix::MultipartSegment {
|
|
name: "basic-mod-different.jar".to_string(),
|
|
filename: Some("basic-mod.jar".to_string()),
|
|
content_type: Some("application/java-archive".to_string()),
|
|
data: labrinth::util::actix::MultipartSegmentData::Binary(
|
|
include_bytes!("../../../tests/files/basic-mod-different.jar").to_vec(),
|
|
),
|
|
};
|
|
|
|
let request = test::TestRequest::post()
|
|
.uri("/v3/version")
|
|
.set_multipart(vec![json_segment.clone(), file_segment.clone()])
|
|
.append_header((AUTHORIZATION, pat))
|
|
.to_request();
|
|
let resp = self.call(request).await;
|
|
assert_status(&resp, StatusCode::OK);
|
|
test::read_body_json(resp).await
|
|
}
|
|
|
|
pub async fn get_versions(&self, version_ids: Vec<String>, pat: &str) -> Vec<Version> {
|
|
let ids = url_encode_json_serialized_vec(&version_ids);
|
|
let request = test::TestRequest::get()
|
|
.uri(&format!("/v3/versions?ids={}", ids))
|
|
.append_header((AUTHORIZATION, pat))
|
|
.to_request();
|
|
let resp = self.call(request).await;
|
|
assert_status(&resp, StatusCode::OK);
|
|
test::read_body_json(resp).await
|
|
}
|
|
|
|
pub async fn edit_version_ordering(
|
|
&self,
|
|
version_id: &str,
|
|
ordering: Option<i32>,
|
|
pat: &str,
|
|
) -> ServiceResponse {
|
|
let request = test::TestRequest::patch()
|
|
.uri(&format!("/v3/version/{version_id}"))
|
|
.set_json(json!(
|
|
{
|
|
"ordering": ordering
|
|
}
|
|
))
|
|
.append_header((AUTHORIZATION, pat))
|
|
.to_request();
|
|
self.call(request).await
|
|
}
|
|
}
|