Bommels05/Modrinth
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Version ordering [MOD-551] (#740)

Browse Source 
* Version ordering

* cargo sqlx prepare

* Use version ordering for maven

* Use version ordering when sorting versions in Rust (not just SQL)

* Thanks clippy
This commit is contained in:
Jackson Kruger 2023-11-01 11:36:39 -05:00 committed by GitHub
parent d5594b03e3
commit 911d442340
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 392 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
.sqlx/query-a62767e812783e8836a11b22878a4248123f3fe212a876e192f549acd6edcb39.json → .sqlx/query-1e735a003ce305624ce8bbf181c99e41fbe8fcd836e926daf3e73aa3bb5552a6.json generated
View File

@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
"query": "\n SELECT v.id id, v.mod_id mod_id, v.author_id author_id, v.name version_name, v.version_number version_number,\n v.changelog changelog, v.date_published date_published, v.downloads downloads,\n v.version_type version_type, v.featured featured, v.status status, v.requested_status requested_status,\n JSONB_AGG(DISTINCT jsonb_build_object('version', gv.version, 'created', gv.created)) filter (where gv.version is not null) game_versions,\n ARRAY_AGG(DISTINCT l.loader) filter (where l.loader is not null) loaders,\n JSONB_AGG(DISTINCT jsonb_build_object('id', f.id, 'url', f.url, 'filename', f.filename, 'primary', f.is_primary, 'size', f.size, 'file_type', f.file_type)) filter (where f.id is not null) files,\n JSONB_AGG(DISTINCT jsonb_build_object('algorithm', h.algorithm, 'hash', encode(h.hash, 'escape'), 'file_id', h.file_id)) filter (where h.hash is not null) hashes,\n JSONB_AGG(DISTINCT jsonb_build_object('project_id', d.mod_dependency_id, 'version_id', d.dependency_id, 'dependency_type', d.dependency_type,'file_name', dependency_file_name)) filter (where d.dependency_type is not null) dependencies\n FROM versions v\n LEFT OUTER JOIN game_versions_versions gvv on v.id = gvv.joining_version_id\n LEFT OUTER JOIN game_versions gv on gvv.game_version_id = gv.id\n LEFT OUTER JOIN loaders_versions lv on v.id = lv.version_id\n LEFT OUTER JOIN loaders l on lv.loader_id = l.id\n LEFT OUTER JOIN files f on v.id = f.version_id\n LEFT OUTER JOIN hashes h on f.id = h.file_id\n LEFT OUTER JOIN dependencies d on v.id = d.dependent_id\n WHERE v.id = ANY($1)\n GROUP BY v.id\n ORDER BY v.date_published ASC;\n ",
"query": "\n SELECT v.id id, v.mod_id mod_id, v.author_id author_id, v.name version_name, v.version_number version_number,\n v.changelog changelog, v.date_published date_published, v.downloads downloads,\n v.version_type version_type, v.featured featured, v.status status, v.requested_status requested_status, v.ordering ordering,\n JSONB_AGG(DISTINCT jsonb_build_object('version', gv.version, 'created', gv.created)) filter (where gv.version is not null) game_versions,\n ARRAY_AGG(DISTINCT l.loader) filter (where l.loader is not null) loaders,\n JSONB_AGG(DISTINCT jsonb_build_object('id', f.id, 'url', f.url, 'filename', f.filename, 'primary', f.is_primary, 'size', f.size, 'file_type', f.file_type)) filter (where f.id is not null) files,\n JSONB_AGG(DISTINCT jsonb_build_object('algorithm', h.algorithm, 'hash', encode(h.hash, 'escape'), 'file_id', h.file_id)) filter (where h.hash is not null) hashes,\n JSONB_AGG(DISTINCT jsonb_build_object('project_id', d.mod_dependency_id, 'version_id', d.dependency_id, 'dependency_type', d.dependency_type,'file_name', dependency_file_name)) filter (where d.dependency_type is not null) dependencies\n FROM versions v\n LEFT OUTER JOIN game_versions_versions gvv on v.id = gvv.joining_version_id\n LEFT OUTER JOIN game_versions gv on gvv.game_version_id = gv.id\n LEFT OUTER JOIN loaders_versions lv on v.id = lv.version_id\n LEFT OUTER JOIN loaders l on lv.loader_id = l.id\n LEFT OUTER JOIN files f on v.id = f.version_id\n LEFT OUTER JOIN hashes h on f.id = h.file_id\n LEFT OUTER JOIN dependencies d on v.id = d.dependent_id\n WHERE v.id = ANY($1)\n GROUP BY v.id\n ORDER BY v.ordering ASC NULLS LAST, v.date_published ASC;\n ",
"describe": {
"columns": [
{
@ -65,26 +65,31 @@
},
{
"ordinal": 12,
"name": "ordering",
"type_info": "Int4"
},
{
"ordinal": 13,
"name": "game_versions",
"type_info": "Jsonb"
},
{
"ordinal": 13,
"ordinal": 14,
"name": "loaders",
"type_info": "VarcharArray"
},
{
"ordinal": 14,
"ordinal": 15,
"name": "files",
"type_info": "Jsonb"
},
{
"ordinal": 15,
"ordinal": 16,
"name": "hashes",
"type_info": "Jsonb"
},
{
"ordinal": 16,
"ordinal": 17,
"name": "dependencies",
"type_info": "Jsonb"
}
@ -107,6 +112,7 @@
false,
false,
true,
true,
null,
null,
null,
@ -114,5 +120,5 @@
null
]
},
"hash": "a62767e812783e8836a11b22878a4248123f3fe212a876e192f549acd6edcb39"
"hash": "1e735a003ce305624ce8bbf181c99e41fbe8fcd836e926daf3e73aa3bb5552a6"
}

15
.sqlx/query-54c6b31858b7bf383f9b7118583592d694ab2d80ac0f132c5b9bc42603f336c6.json generated Normal file
View File

@ -0,0 +1,15 @@
{
"db_name": "PostgreSQL",
"query": "\n UPDATE versions\n SET ordering = $1\n WHERE (id = $2)\n ",
"describe": {
"columns": [],
"parameters": {
"Left": [
"Int4",
"Int8"
]
},
"nullable": []
},
"hash": "54c6b31858b7bf383f9b7118583592d694ab2d80ac0f132c5b9bc42603f336c6"
}

7
.sqlx/query-df871bd959ba97f105ac575f34d8d2a39cbc44a07e0339750a0e477e6fd582ed.json → .sqlx/query-a4745a3dc87c3a858819b208b0c3a010dc297425883113565d934b8a834014ce.json generated
View File

@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
"query": "\n INSERT INTO versions (\n id, mod_id, author_id, name, version_number,\n changelog, date_published, downloads,\n version_type, featured, status\n )\n VALUES (\n $1, $2, $3, $4, $5,\n $6, $7, $8,\n $9, $10, $11\n )\n ",
"query": "\n INSERT INTO versions (\n id, mod_id, author_id, name, version_number,\n changelog, date_published, downloads,\n version_type, featured, status, ordering\n )\n VALUES (\n $1, $2, $3, $4, $5,\n $6, $7, $8,\n $9, $10, $11, $12\n )\n ",
"describe": {
"columns": [],
"parameters": {
@ -15,10 +15,11 @@
"Int4",
"Varchar",
"Bool",
"Varchar"
"Varchar",
"Int4"
]
},
"nullable": []
},
"hash": "df871bd959ba97f105ac575f34d8d2a39cbc44a07e0339750a0e477e6fd582ed"
"hash": "a4745a3dc87c3a858819b208b0c3a010dc297425883113565d934b8a834014ce"
}

4
.sqlx/query-f3d7eb1b62f0b978787dba1132308d070d28911d6ddc380cedfa16e7baa3243a.json → .sqlx/query-defc616ab6e602d87695371761563a023a96a860270a2f2afcdd48087e441dad.json generated
View File

@ -1,6 +1,6 @@
{
"db_name": "PostgreSQL",
"query": "\n SELECT id, version_number, version_type\n FROM versions\n WHERE mod_id = $1 AND status = ANY($2)\n ORDER BY date_published ASC\n ",
"query": "\n SELECT id, version_number, version_type\n FROM versions\n WHERE mod_id = $1 AND status = ANY($2)\n ORDER BY ordering ASC NULLS LAST, date_published ASC\n ",
"describe": {
"columns": [
{
@ -31,5 +31,5 @@
false
]
},
"hash": "f3d7eb1b62f0b978787dba1132308d070d28911d6ddc380cedfa16e7baa3243a"
"hash": "defc616ab6e602d87695371761563a023a96a860270a2f2afcdd48087e441dad"
}

1
migrations/20231027195838_version_ordering.sql Normal file
View File

@ -0,0 +1 @@
ALTER TABLE versions ADD COLUMN ordering int NULL;

104
src/database/models/version_item.rs
View File

@ -28,6 +28,7 @@ pub struct VersionBuilder {
pub featured: bool,
pub status: VersionStatus,
pub requested_status: Option<VersionStatus>,
pub ordering: Option<i32>,
}
#[derive(Clone)]
@ -214,6 +215,7 @@ impl VersionBuilder {
version_type: self.version_type,
status: self.status,
requested_status: self.requested_status,
ordering: self.ordering,
};
version.insert(transaction).await?;
@ -317,7 +319,7 @@ impl VersionVersion {
}
}
#[derive(Clone, Deserialize, Serialize)]
#[derive(Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct Version {
pub id: VersionId,
pub project_id: ProjectId,
@ -332,6 +334,7 @@ pub struct Version {
pub featured: bool,
pub status: VersionStatus,
pub requested_status: Option<VersionStatus>,
pub ordering: Option<i32>,
}
impl Version {
@ -344,12 +347,12 @@ impl Version {
INSERT INTO versions (
id, mod_id, author_id, name, version_number,
changelog, date_published, downloads,
version_type, featured, status
version_type, featured, status, ordering
)
VALUES (
$1, $2, $3, $4, $5,
$6, $7, $8,
$9, $10, $11
$9, $10, $11, $12
)
",
self.id as VersionId,
@ -362,7 +365,8 @@ impl Version {
self.downloads,
&self.version_type,
self.featured,
self.status.as_str()
self.status.as_str(),
self.ordering
)
.execute(&mut **transaction)
.await?;
@ -554,7 +558,7 @@ impl Version {
"
SELECT v.id id, v.mod_id mod_id, v.author_id author_id, v.name version_name, v.version_number version_number,
v.changelog changelog, v.date_published date_published, v.downloads downloads,
v.version_type version_type, v.featured featured, v.status status, v.requested_status requested_status,
v.version_type version_type, v.featured featured, v.status status, v.requested_status requested_status, v.ordering ordering,
JSONB_AGG(DISTINCT jsonb_build_object('version', gv.version, 'created', gv.created)) filter (where gv.version is not null) game_versions,
ARRAY_AGG(DISTINCT l.loader) filter (where l.loader is not null) loaders,
JSONB_AGG(DISTINCT jsonb_build_object('id', f.id, 'url', f.url, 'filename', f.filename, 'primary', f.is_primary, 'size', f.size, 'file_type', f.file_type)) filter (where f.id is not null) files,
@ -570,7 +574,7 @@ impl Version {
LEFT OUTER JOIN dependencies d on v.id = d.dependent_id
WHERE v.id = ANY($1)
GROUP BY v.id
ORDER BY v.date_published ASC;
ORDER BY v.ordering ASC NULLS LAST, v.date_published ASC;
",
&version_ids_parsed
)
@ -593,6 +597,7 @@ impl Version {
status: VersionStatus::from_string(&v.status),
requested_status: v.requested_status
.map(|x| VersionStatus::from_string(&x)),
ordering: v.ordering,
},
files: {
#[derive(Deserialize)]
@ -851,7 +856,7 @@ impl Version {
}
}
#[derive(Clone, Deserialize, Serialize)]
#[derive(Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct QueryVersion {
pub inner: Version,
@ -861,7 +866,7 @@ pub struct QueryVersion {
pub dependencies: Vec<QueryDependency>,
}
#[derive(Clone, Deserialize, Serialize)]
#[derive(Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct QueryDependency {
pub project_id: Option<ProjectId>,
pub version_id: Option<VersionId>,
@ -869,7 +874,7 @@ pub struct QueryDependency {
pub dependency_type: String,
}
#[derive(Clone, Deserialize, Serialize)]
#[derive(Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct QueryFile {
pub id: FileId,
pub url: String,
@ -892,3 +897,84 @@ pub struct SingleFile {
pub size: u32,
pub file_type: Option<FileType>,
}
impl std::cmp::Ord for QueryVersion {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
self.inner.cmp(&other.inner)
}
}
impl std::cmp::PartialOrd for QueryVersion {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl std::cmp::Ord for Version {
fn cmp(&self, other: &Self) -> Ordering {
let ordering_order = match (self.ordering, other.ordering) {
(None, None) => Ordering::Equal,
(None, Some(_)) => Ordering::Greater,
(Some(_), None) => Ordering::Less,
(Some(a), Some(b)) => a.cmp(&b),
};
match ordering_order {
Ordering::Equal => self.date_published.cmp(&other.date_published),
ordering => ordering,
}
}
}
impl std::cmp::PartialOrd for Version {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
#[cfg(test)]
mod tests {
use chrono::Months;
use super::*;
#[test]
fn test_version_sorting() {
let versions = vec![
get_version(4, None, months_ago(6)),
get_version(3, None, months_ago(7)),
get_version(2, Some(1), months_ago(6)),
get_version(1, Some(0), months_ago(4)),
get_version(0, Some(0), months_ago(5)),
];
let sorted = versions.iter().cloned().sorted().collect_vec();
let expected_sorted_ids = vec![0, 1, 2, 3, 4];
let actual_sorted_ids = sorted.iter().map(|v| v.id.0).collect_vec();
assert_eq!(expected_sorted_ids, actual_sorted_ids);
}
fn months_ago(months: u32) -> DateTime<Utc> {
Utc::now().checked_sub_months(Months::new(months)).unwrap()
}
fn get_version(id: i64, ordering: Option<i32>, date_published: DateTime<Utc>) -> Version {
Version {
id: VersionId(id),
ordering,
date_published,
project_id: ProjectId(0),
author_id: UserId(0),
name: Default::default(),
version_number: Default::default(),
changelog: Default::default(),
changelog_url: Default::default(),
downloads: Default::default(),
version_type: Default::default(),
featured: Default::default(),
status: VersionStatus::Listed,
requested_status: Default::default(),
}
}
}

5
src/models/projects.rs
View File

@ -491,6 +491,8 @@ pub struct Version {
pub game_versions: Vec<GameVersion>,
/// The loaders that this version works on
pub loaders: Vec<Loader>,
/// Ordering override, lower is returned first
pub ordering: Option<i32>,
}
impl From<QueryVersion> for Version {
@ -515,6 +517,7 @@ impl From<QueryVersion> for Version {
"alpha" => VersionType::Alpha,
_ => VersionType::Release,
},
ordering: v.ordering,
status: v.status,
requested_status: v.requested_status,
@ -729,7 +732,7 @@ impl DependencyType {
}
}
#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum FileType {
RequiredResourcePack,

2
src/routes/maven.rs
View File

@ -100,7 +100,7 @@ pub async fn maven_metadata(
SELECT id, version_number, version_type
FROM versions
WHERE mod_id = $1 AND status = ANY($2)
ORDER BY date_published ASC
ORDER BY ordering ASC NULLS LAST, date_published ASC
",
project.inner.id as database::models::ids::ProjectId,
&*crate::models::projects::VersionStatus::iterator()

1
src/routes/v2/project_creation.rs
View File

@ -964,6 +964,7 @@ async fn create_initial_version(
status: VersionStatus::Listed,
version_type: version_data.release_channel.to_string(),
requested_status: None,
ordering: version_data.ordering,
};
Ok(version)

5
src/routes/v2/version_creation.rs
View File

@ -76,6 +76,9 @@ pub struct InitialVersionData {
#[validate(length(max = 10))]
#[serde(default)]
pub uploaded_images: Vec<ImageId>,
// The ordering relative to other versions
pub ordering: Option<i32>,
}
#[derive(Serialize, Deserialize, Clone)]
@ -316,6 +319,7 @@ async fn version_create_inner(
featured: version_create_data.featured,
status: version_create_data.status,
requested_status: None,
ordering: version_create_data.ordering,
});
return Ok(());
@ -427,6 +431,7 @@ async fn version_create_inner(
version_type: version_data.release_channel,
status: builder.status,
requested_status: builder.requested_status,
ordering: builder.ordering,
files: builder
.files
.iter()

6
src/routes/v2/version_file.rs
View File

@ -323,7 +323,7 @@ pub async fn get_update_from_hash(
bool
})
.sorted_by(|a, b| a.inner.date_published.cmp(&b.inner.date_published))
.sorted()
.collect::<Vec<_>>();
if let Some(first) = versions.pop() {
@ -522,7 +522,7 @@ pub async fn update_files(
bool
})
.sorted_by(|a, b| b.inner.date_published.cmp(&a.inner.date_published))
.sorted()
.next();
if let Some(version) = version {
@ -629,7 +629,7 @@ pub async fn update_individual_files(
bool
})
.sorted_by(|a, b| b.inner.date_published.cmp(&a.inner.date_published))
.sorted()
.next();
if let Some(version) = version {

19
src/routes/v2/versions.rs
View File

@ -115,7 +115,7 @@ pub async fn version_list(
.cloned()
.collect::<Vec<_>>();
versions.sort_by(|a, b| b.inner.date_published.cmp(&a.inner.date_published));
versions.sort();
// Attempt to populate versions with "auto featured" versions
if response.is_empty() && !versions.is_empty() && filters.featured.unwrap_or(false) {
@ -155,7 +155,7 @@ pub async fn version_list(
}
}
response.sort_by(|a, b| b.inner.date_published.cmp(&a.inner.date_published));
response.sort();
response.dedup_by(|a, b| a.inner.id == b.inner.id);
let response = filter_authorized_versions(response, &user_option, &pool).await?;
@ -306,6 +306,7 @@ pub struct EditVersion {
pub downloads: Option<u32>,
pub status: Option<VersionStatus>,
pub file_types: Option<Vec<EditVersionFileType>>,
pub ordering: Option<Option<i32>>, //TODO: How do you actually pass this in json?
}
#[derive(Serialize, Deserialize)]
@ -684,6 +685,20 @@ pub async fn version_edit(
}
}
if let Some(ordering) = &new_version.ordering {
sqlx::query!(
"
UPDATE versions
SET ordering = $1
WHERE (id = $2)
",
ordering.to_owned() as Option<i32>,
id as database::models::ids::VersionId,
)
.execute(&mut *transaction)
.await?;
}
// delete any images no longer in the changelog
let checkable_strings: Vec<&str> = vec![&new_version.changelog]
.into_iter()

1
tests/common/api_v2/mod.rs
View File

@ -7,6 +7,7 @@ use std::rc::Rc;
pub mod organization;
pub mod project;
pub mod team;
pub mod version;
#[derive(Clone)]
pub struct ApiV2 {

91
tests/common/api_v2/version.rs Normal file
View File

@ -0,0 +1,91 @@
use actix_http::{header::AUTHORIZATION, StatusCode};
use actix_web::{dev::ServiceResponse, test};
use labrinth::models::projects::Version;
use serde_json::json;
use crate::common::{self, actix::AppendsMultipart, asserts::assert_status};
use super::ApiV2;
pub fn url_encode_json_serialized_vec(elements: &[String]) -> String {
let serialized = serde_json::to_string(&elements).unwrap();
urlencoding::encode(&serialized).to_string()
}
impl ApiV2 {
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"] ,
"release_channel": "release",
"loaders": ["fabric"],
"featured": true,
"ordering": ordering,
}
);
let json_segment = common::actix::MultipartSegment {
name: "data".to_string(),
filename: None,
content_type: Some("application/json".to_string()),
data: common::actix::MultipartSegmentData::Text(
serde_json::to_string(&json_data).unwrap(),
),
};
let file_segment = common::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: common::actix::MultipartSegmentData::Binary(
include_bytes!("../../../tests/files/basic-mod-different.jar").to_vec(),
),
};
let request = test::TestRequest::post()
.uri("/v2/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!("/v2/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!("/v2/version/{version_id}"))
.set_json(json!(
{
"ordering": ordering
}
))
.append_header((AUTHORIZATION, pat))
.to_request();
self.call(request).await
}
}

14
tests/common/asserts.rs
View File

@ -1,9 +1,23 @@
#![allow(dead_code)]
use crate::common::get_json_val_str;
use itertools::Itertools;
pub fn assert_status(response: &actix_web::dev::ServiceResponse, status: actix_http::StatusCode) {
assert_eq!(response.status(), status, "{:#?}", response.response());
}
pub fn assert_version_ids(
versions: &[labrinth::models::projects::Version],
expected_ids: Vec<String>,
) {
let version_ids = versions
.iter()
.map(|v| get_json_val_str(v.id))
.collect_vec();
assert_eq!(version_ids, expected_ids);
}
pub fn assert_any_status_except(
response: &actix_web::dev::ServiceResponse,
status: actix_http::StatusCode,

126
tests/version.rs Normal file
View File

@ -0,0 +1,126 @@
use crate::common::{asserts::assert_status, get_json_val_str};
use actix_http::StatusCode;
use common::{
asserts::assert_version_ids, database::USER_USER_PAT, environment::with_test_environment,
};
mod common;
#[actix_rt::test]
async fn can_create_version_with_ordering() {
with_test_environment(|env| async move {
let alpha_project_id = env.dummy.as_ref().unwrap().project_alpha.project_id.clone();
let new_version_id = get_json_val_str(
env.v2
.create_default_version(&alpha_project_id, Some(1), USER_USER_PAT)
.await
.id,
);
let versions = env
.v2
.get_versions(vec![new_version_id.clone()], USER_USER_PAT)
.await;
assert_eq!(versions[0].ordering, Some(1));
})
.await;
}
#[actix_rt::test]
async fn edit_version_ordering_works() {
with_test_environment(|env| async move {
let alpha_version_id = env.dummy.as_ref().unwrap().project_alpha.version_id.clone();
let resp = env
.v2
.edit_version_ordering(&alpha_version_id, Some(10), USER_USER_PAT)
.await;
assert_status(&resp, StatusCode::NO_CONTENT);
let versions = env
.v2
.get_versions(vec![alpha_version_id.clone()], USER_USER_PAT)
.await;
assert_eq!(versions[0].ordering, Some(10));
})
.await;
}
#[actix_rt::test]
async fn version_ordering_for_specified_orderings_orders_lower_order_first() {
with_test_environment(|env| async move {
let alpha_project_id = env.dummy.as_ref().unwrap().project_alpha.project_id.clone();
let alpha_version_id = env.dummy.as_ref().unwrap().project_alpha.version_id.clone();
let new_version_id = get_json_val_str(
env.v2
.create_default_version(&alpha_project_id, Some(1), USER_USER_PAT)
.await
.id,
);
env.v2
.edit_version_ordering(&alpha_version_id, Some(10), USER_USER_PAT)
.await;
let versions = env
.v2
.get_versions(
vec![alpha_version_id.clone(), new_version_id.clone()],
USER_USER_PAT,
)
.await;
assert_version_ids(&versions, vec![new_version_id, alpha_version_id]);
})
.await;
}
#[actix_rt::test]
async fn version_ordering_when_unspecified_orders_oldest_first() {
with_test_environment(|env| async move {
let alpha_project_id = &env.dummy.as_ref().unwrap().project_alpha.project_id.clone();
let alpha_version_id = env.dummy.as_ref().unwrap().project_alpha.version_id.clone();
let new_version_id = get_json_val_str(
env.v2
.create_default_version(&alpha_project_id, None, USER_USER_PAT)
.await
.id,
);
let versions = env
.v2
.get_versions(
vec![alpha_version_id.clone(), new_version_id.clone()],
USER_USER_PAT,
)
.await;
assert_version_ids(&versions, vec![alpha_version_id, new_version_id]);
})
.await
}
#[actix_rt::test]
async fn version_ordering_when_specified_orders_specified_before_unspecified() {
with_test_environment(|env| async move {
let alpha_project_id = &env.dummy.as_ref().unwrap().project_alpha.project_id.clone();
let alpha_version_id = env.dummy.as_ref().unwrap().project_alpha.version_id.clone();
let new_version_id = get_json_val_str(
env.v2
.create_default_version(&alpha_project_id, Some(10000), USER_USER_PAT)
.await
.id,
);
env.v2
.edit_version_ordering(&alpha_version_id, None, USER_USER_PAT)
.await;
let versions = env
.v2
.get_versions(
vec![alpha_version_id.clone(), new_version_id.clone()],
USER_USER_PAT,
)
.await;
assert_version_ids(&versions, vec![new_version_id, alpha_version_id]);
})
.await;
}