Misc v3 linear tasks (#767)

* v3_reroute 404 error

* hash change

* fixed issue with error conversion

* added new model confirmation tests
+ title name change

* renaming, fields

* owner; test changes

* clippy prepare

* fmt

* merge fixes

* clippy

* working merge

* revs

* merge fixes

tests/common/api_v3/organization.rs

@@ -6,9 +6,9 @@ use bytes::Bytes;
 use labrinth::models::{organizations::Organization, v3::projects::Project};
 use serde_json::json;
 
-use crate::common::api_common::Api;
+use crate::common::api_common::{request_data::ImageData, Api};
 
-use super::{request_data::ImageData, ApiV3};
+use super::ApiV3;
 
 impl ApiV3 {
     pub async fn create_organization(
@@ -21,7 +21,7 @@ impl ApiV3 {
             .uri("/v3/organization")
             .append_header(("Authorization", pat))
             .set_json(json!({
-                "title": organization_title,
+                "name": organization_title,
                 "description": description,
             }))
             .to_request();

tests/common/api_v3/project.rs

@@ -15,6 +15,7 @@ use serde_json::json;
 use crate::common::{
     api_common::{
         models::{CommonImageData, CommonProject, CommonVersion},
+        request_data::ProjectCreationRequestData,
         Api, ApiProject,
     },
     asserts::assert_status,
@@ -22,7 +23,10 @@ use crate::common::{
     dummy_data::TestFile,
 };
 
-use super::{request_data::get_public_project_creation_data, ApiV3};
+use super::{
+    request_data::{self, get_public_project_creation_data},
+    ApiV3,
+};
 
 #[async_trait(?Send)]
 impl ApiProject for ApiV3 {
@@ -36,17 +40,13 @@ impl ApiProject for ApiV3 {
         let creation_data = get_public_project_creation_data(slug, version_jar, modify_json);
 
         // Add a project.
-        let req = TestRequest::post()
-            .uri("/v3/project")
-            .append_header(("Authorization", pat))
-            .set_multipart(creation_data.segment_data)
-            .to_request();
-        let resp = self.call(req).await;
+        let slug = creation_data.slug.clone();
+        let resp = self.create_project(creation_data, pat).await;
         assert_status(&resp, StatusCode::OK);
 
         // Approve as a moderator.
         let req = TestRequest::patch()
-            .uri(&format!("/v3/project/{}", creation_data.slug))
+            .uri(&format!("/v3/project/{}", slug))
             .append_header(("Authorization", MOD_USER_PAT))
             .set_json(json!(
                 {
@@ -57,12 +57,12 @@ impl ApiProject for ApiV3 {
         let resp = self.call(req).await;
         assert_status(&resp, StatusCode::NO_CONTENT);
 
-        let project = self.get_project(&creation_data.slug, pat).await;
+        let project = self.get_project(&slug, pat).await;
         let project = test::read_body_json(project).await;
 
         // Get project's versions
         let req = TestRequest::get()
-            .uri(&format!("/v3/project/{}/version", creation_data.slug))
+            .uri(&format!("/v3/project/{}/version", slug))
             .append_header(("Authorization", pat))
             .to_request();
         let resp = self.call(req).await;
@@ -71,6 +71,27 @@ impl ApiProject for ApiV3 {
         (project, versions)
     }
 
+    async fn get_public_project_creation_data_json(
+        &self,
+        slug: &str,
+        version_jar: Option<&TestFile>,
+    ) -> serde_json::Value {
+        request_data::get_public_project_creation_data_json(slug, version_jar)
+    }
+
+    async fn create_project(
+        &self,
+        creation_data: ProjectCreationRequestData,
+        pat: &str,
+    ) -> ServiceResponse {
+        let req = TestRequest::post()
+            .uri("/v3/project")
+            .append_header(("Authorization", pat))
+            .set_multipart(creation_data.segment_data)
+            .to_request();
+        self.call(req).await
+    }
+
     async fn remove_project(&self, project_slug_or_id: &str, pat: &str) -> ServiceResponse {
         let req = test::TestRequest::delete()
             .uri(&format!("/v3/project/{project_slug_or_id}"))
@@ -92,7 +113,11 @@ impl ApiProject for ApiV3 {
     async fn get_project_deserialized_common(&self, id_or_slug: &str, pat: &str) -> CommonProject {
         let resp = self.get_project(id_or_slug, pat).await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let project: Project = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(project).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     async fn get_user_projects(&self, user_id_or_username: &str, pat: &str) -> ServiceResponse {
@@ -110,7 +135,11 @@ impl ApiProject for ApiV3 {
     ) -> Vec<CommonProject> {
         let resp = self.get_user_projects(user_id_or_username, pat).await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let projects: Vec<Project> = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(projects).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     async fn edit_project(

tests/common/api_v3/request_data.rs

@@ -1,30 +1,15 @@
 #![allow(dead_code)]
 use serde_json::json;
 
-use crate::common::dummy_data::{DummyImage, TestFile};
+use crate::common::{
+    api_common::request_data::{ImageData, ProjectCreationRequestData, VersionCreationRequestData},
+    dummy_data::{DummyImage, TestFile},
+};
 use labrinth::{
     models::projects::ProjectId,
     util::actix::{MultipartSegment, MultipartSegmentData},
 };
 
-pub struct ProjectCreationRequestData {
-    pub slug: String,
-    pub jar: Option<TestFile>,
-    pub segment_data: Vec<MultipartSegment>,
-}
-
-pub struct VersionCreationRequestData {
-    pub version: String,
-    pub jar: Option<TestFile>,
-    pub segment_data: Vec<MultipartSegment>,
-}
-
-pub struct ImageData {
-    pub filename: String,
-    pub extension: String,
-    pub icon: Vec<u8>,
-}
-
 pub fn get_public_project_creation_data(
     slug: &str,
     version_jar: Option<TestFile>,
@@ -110,10 +95,10 @@ pub fn get_public_project_creation_data_json(
     let is_draft = version_jar.is_none();
     json!(
         {
-            "title": format!("Test Project {slug}"),
+            "name": format!("Test Project {slug}"),
             "slug": slug,
-            "description": "A dummy project for testing with.",
-            "body": "This project is approved, and versions are listed.",
+            "summary": "A dummy project for testing with.",
+            "description": "This project is approved, and versions are listed.",
             "initial_versions": initial_versions,
             "is_draft": is_draft,
             "categories": [],

tests/common/api_v3/tags.rs

@@ -3,8 +3,10 @@ use actix_web::{
     test::{self, TestRequest},
 };
 use async_trait::async_trait;
-use labrinth::database::models::loader_fields::LoaderFieldEnumValue;
 use labrinth::routes::v3::tags::{GameData, LoaderData};
+use labrinth::{
+    database::models::loader_fields::LoaderFieldEnumValue, routes::v3::tags::CategoryData,
+};
 
 use crate::common::{
     api_common::{
@@ -29,7 +31,11 @@ impl ApiTags for ApiV3 {
     async fn get_loaders_deserialized_common(&self) -> Vec<CommonLoaderData> {
         let resp = self.get_loaders().await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: Vec<LoaderData> = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     async fn get_categories(&self) -> ServiceResponse {
@@ -43,7 +49,11 @@ impl ApiTags for ApiV3 {
     async fn get_categories_deserialized_common(&self) -> Vec<CommonCategoryData> {
         let resp = self.get_categories().await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: Vec<CategoryData> = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 }
 

tests/common/api_v3/team.rs

@@ -1,7 +1,10 @@
 use actix_http::StatusCode;
 use actix_web::{dev::ServiceResponse, test};
 use async_trait::async_trait;
-use labrinth::models::teams::{OrganizationPermissions, ProjectPermissions};
+use labrinth::models::{
+    notifications::Notification,
+    teams::{OrganizationPermissions, ProjectPermissions, TeamMember},
+};
 use serde_json::json;
 
 use crate::common::{
@@ -14,6 +17,24 @@ use crate::common::{
 
 use super::ApiV3;
 
+impl ApiV3 {
+    pub async fn get_organization_members_deserialized(
+        &self,
+        id_or_title: &str,
+        pat: &str,
+    ) -> Vec<TeamMember> {
+        let resp = self.get_organization_members(id_or_title, pat).await;
+        assert_eq!(resp.status(), 200);
+        test::read_body_json(resp).await
+    }
+
+    pub async fn get_team_members_deserialized(&self, team_id: &str, pat: &str) -> Vec<TeamMember> {
+        let resp = self.get_team_members(team_id, pat).await;
+        assert_eq!(resp.status(), 200);
+        test::read_body_json(resp).await
+    }
+}
+
 #[async_trait(?Send)]
 impl ApiTeams for ApiV3 {
     async fn get_team_members(&self, id_or_title: &str, pat: &str) -> ServiceResponse {
@@ -31,7 +52,11 @@ impl ApiTeams for ApiV3 {
     ) -> Vec<CommonTeamMember> {
         let resp = self.get_team_members(id_or_title, pat).await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: Vec<TeamMember> = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     async fn get_project_members(&self, id_or_title: &str, pat: &str) -> ServiceResponse {
@@ -49,7 +74,11 @@ impl ApiTeams for ApiV3 {
     ) -> Vec<CommonTeamMember> {
         let resp = self.get_project_members(id_or_title, pat).await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: Vec<TeamMember> = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     async fn get_organization_members(&self, id_or_title: &str, pat: &str) -> ServiceResponse {
@@ -67,7 +96,11 @@ impl ApiTeams for ApiV3 {
     ) -> Vec<CommonTeamMember> {
         let resp = self.get_organization_members(id_or_title, pat).await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: Vec<TeamMember> = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     async fn join_team(&self, team_id: &str, pat: &str) -> ServiceResponse {
@@ -132,7 +165,11 @@ impl ApiTeams for ApiV3 {
     ) -> Vec<CommonNotification> {
         let resp = self.get_user_notifications(user_id, pat).await;
         assert_status(&resp, StatusCode::OK);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: Vec<Notification> = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     async fn mark_notification_read(&self, notification_id: &str, pat: &str) -> ServiceResponse {

tests/common/api_v3/version.rs

@@ -138,7 +138,11 @@ impl ApiVersion for ApiV3 {
             )
             .await;
         assert_status(&resp, StatusCode::OK);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: Version = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     async fn get_version(&self, id: &str, pat: &str) -> ServiceResponse {
@@ -152,7 +156,11 @@ impl ApiVersion for ApiV3 {
     async fn get_version_deserialized_common(&self, id: &str, pat: &str) -> CommonVersion {
         let resp = self.get_version(id, pat).await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: Version = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     async fn edit_version(
@@ -191,7 +199,11 @@ impl ApiVersion for ApiV3 {
     ) -> CommonVersion {
         let resp = self.get_version_from_hash(hash, algorithm, pat).await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: Version = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     async fn get_versions_from_hashes(
@@ -219,7 +231,11 @@ impl ApiVersion for ApiV3 {
     ) -> HashMap<String, CommonVersion> {
         let resp = self.get_versions_from_hashes(hashes, algorithm, pat).await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: HashMap<String, Version> = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     async fn get_update_from_hash(
@@ -267,7 +283,11 @@ impl ApiVersion for ApiV3 {
             .get_update_from_hash(hash, algorithm, loaders, game_versions, version_types, pat)
             .await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: Version = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     async fn update_files(
@@ -323,7 +343,11 @@ impl ApiVersion for ApiV3 {
             )
             .await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: HashMap<String, Version> = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     // TODO: Not all fields are tested currently in the v3 tests, only the v2-v3 relevant ones are
@@ -402,7 +426,11 @@ impl ApiVersion for ApiV3 {
             )
             .await;
         assert_eq!(resp.status(), 200);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: Vec<Version> = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 
     // TODO: remove redundancy in these functions
@@ -440,6 +468,10 @@ impl ApiVersion for ApiV3 {
     ) -> Vec<CommonVersion> {
         let resp = self.get_versions(version_ids, pat).await;
         assert_status(&resp, StatusCode::OK);
-        test::read_body_json(resp).await
+        // First, deserialize to the non-common format (to test the response is valid for this api version)
+        let v: Vec<Version> = test::read_body_json(resp).await;
+        // Then, deserialize to the common format
+        let value = serde_json::to_value(v).unwrap();
+        serde_json::from_value(value).unwrap()
     }
 }