chk
/
AppFlowy-Cloud
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: support for original and modified namespace

This commit is contained in:
Zack Fu Zi Xiang 2024-11-04 16:58:33 +08:00
parent 58efe8417e
commit 8d8c895703
No known key found for this signature in database
10 changed files with 179 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libs/client-api-wasm/src/lib.rs
View File

@ -256,7 +256,7 @@ impl ClientAPI {
})?;
match self.client.get_published_collab_info(&view_id).await {
Ok(info) => Ok(PublishInfo {
namespace: info.namespace,
namespace: Some(info.namespace),
publish_name: info.publish_name,
}),
Err(err) => Err(ClientResponse::from(err)),

9
libs/client-api/src/http_publish.rs
View File

@ -35,11 +35,15 @@ impl Client {
.into_data()
}
/// Changes the namespace for the first non-original publish namespace
/// or the original publish namespace if not exists.
pub async fn set_workspace_publish_namespace(
&self,
workspace_id: &str,
new_namespace: &str,
new_namespace: String,
) -> Result<(), AppResponseError> {
let old_namespace = self.get_workspace_publish_namespace(workspace_id).await?;
let url = format!(
"{}/api/workspace/{}/publish-namespace",
self.base_url, workspace_id
@ -49,7 +53,8 @@ impl Client {
.http_client_with_auth(Method::PUT, &url)
.await?
.json(&UpdatePublishNamespace {
new_namespace: new_namespace.to_string(),
old_namespace,
new_namespace,
})
.send()
.await?;

10
libs/database-entity/src/dto.rs
View File

@ -372,6 +372,7 @@ pub struct CollabMemberIdentify {
#[derive(Serialize, Deserialize)]
pub struct UpdatePublishNamespace {
pub old_namespace: String,
pub new_namespace: String,
}
@ -411,7 +412,7 @@ pub struct AFCollabMember {
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct PublishInfo {
pub namespace: Option<String>,
pub namespace: String,
pub publish_name: String,
pub view_id: Uuid,
#[serde(default)]
@ -1509,6 +1510,13 @@ pub struct CreateImportTaskResponse {
pub presigned_url: String,
}
#[derive(Debug)]
pub struct WorkspaceNamespace {
pub workspace_id: Uuid,
pub namespace: String,
pub is_original: bool,
}
#[cfg(test)]
mod test {
use crate::dto::{

145
libs/database/src/publish.rs
View File

@ -1,6 +1,6 @@
use app_error::AppError;
use database_entity::dto::{
PatchPublishedCollab, PublishCollabItem, PublishCollabKey, PublishInfo,
PatchPublishedCollab, PublishCollabItem, PublishCollabKey, PublishInfo, WorkspaceNamespace,
};
use sqlx::{Executor, PgPool, Postgres};
use uuid::Uuid;
@ -41,8 +41,8 @@ pub async fn select_workspace_publish_namespace_exists<'a, E: Executor<'a, Datab
r#"
SELECT EXISTS(
SELECT 1
FROM af_workspace
WHERE publish_namespace = $1
FROM af_workspace_namespace
WHERE namespace = $1
)
"#,
namespace,
@ -54,19 +54,26 @@ pub async fn select_workspace_publish_namespace_exists<'a, E: Executor<'a, Datab
}
#[inline]
pub async fn update_workspace_publish_namespace<'a, E: Executor<'a, Database = Postgres>>(
pub async fn update_non_orginal_workspace_publish_namespace<
'a,
E: Executor<'a, Database = Postgres>,
>(
executor: E,
workspace_id: &Uuid,
old_namespace: &str,
new_namespace: &str,
) -> Result<(), AppError> {
let res = sqlx::query!(
r#"
UPDATE af_workspace
SET publish_namespace = $1
UPDATE af_workspace_namespace
SET namespace = $1
WHERE workspace_id = $2
AND namespace = $3
AND is_original = FALSE
"#,
new_namespace,
workspace_id,
old_namespace,
)
.execute(executor)
.await?;
@ -140,19 +147,20 @@ pub async fn update_workspace_default_publish_view_set_null<
}
#[inline]
pub async fn select_workspace_publish_namespace<'a, E: Executor<'a, Database = Postgres>>(
pub async fn select_workspace_publish_namespaces<'a, E: Executor<'a, Database = Postgres>>(
executor: E,
workspace_id: &Uuid,
) -> Result<String, AppError> {
let res = sqlx::query_scalar!(
) -> Result<Vec<WorkspaceNamespace>, AppError> {
let res = sqlx::query_as!(
WorkspaceNamespace,
r#"
SELECT publish_namespace
FROM af_workspace
SELECT workspace_id, namespace, is_original
FROM af_workspace_namespace
WHERE workspace_id = $1
"#,
workspace_id,
)
.fetch_one(executor)
.fetch_all(executor)
.await?;
Ok(res)
@ -225,7 +233,7 @@ pub async fn select_publish_collab_meta<'a, E: Executor<'a, Database = Postgres>
r#"
SELECT metadata
FROM af_published_collab
WHERE workspace_id = (SELECT workspace_id FROM af_workspace WHERE publish_namespace = $1)
WHERE workspace_id = (SELECT workspace_id FROM af_workspace_namespace WHERE namespace = $1)
AND publish_name = $2
"#,
publish_namespace,
@ -354,7 +362,7 @@ pub async fn select_published_collab_workspace_view_id<'a, E: Executor<'a, Datab
r#"
SELECT workspace_id, view_id
FROM af_published_collab
WHERE workspace_id = (SELECT workspace_id FROM af_workspace WHERE publish_namespace = $1)
WHERE workspace_id = (SELECT workspace_id FROM af_workspace_namespace WHERE namespace = $1)
AND publish_name = $2
"#,
publish_namespace,
@ -375,7 +383,7 @@ pub async fn select_published_collab_blob<'a, E: Executor<'a, Database = Postgre
r#"
SELECT blob
FROM af_published_collab
WHERE workspace_id = (SELECT workspace_id FROM af_workspace WHERE publish_namespace = $1)
WHERE workspace_id = (SELECT workspace_id FROM af_workspace_namespace WHERE namespace = $1)
AND publish_name = $2
"#,
publish_namespace,
@ -398,7 +406,7 @@ pub async fn select_default_published_view_id_for_namespace<
r#"
SELECT default_published_view_id
FROM af_workspace
WHERE publish_namespace = $1
WHERE workspace_id = (SELECT workspace_id FROM af_workspace_namespace WHERE namespace = $1)
"#,
namespace,
)
@ -426,15 +434,36 @@ pub async fn select_default_published_view_id<'a, E: Executor<'a, Database = Pos
Ok(res)
}
pub async fn select_published_collab_info_for_view_ids<'a, E: Executor<'a, Database = Postgres>>(
executor: E,
async fn select_first_non_original_namespace(
pg_pool: &PgPool,
namespace: &str,
) -> Result<Option<String>, AppError> {
let res = sqlx::query_scalar!(
r#"
SELECT namespace
FROM af_workspace_namespace
WHERE workspace_id = (SELECT workspace_id FROM af_workspace_namespace WHERE namespace = $1)
AND is_original = FALSE
ORDER BY created_at ASC
LIMIT 1
"#,
namespace,
)
.fetch_optional(pg_pool)
.await?;
Ok(res)
}
pub async fn select_published_collab_info_for_view_ids(
pg_pool: &PgPool,
view_ids: &[Uuid],
) -> Result<Vec<PublishInfo>, AppError> {
let res = sqlx::query_as!(
let mut res = sqlx::query_as!(
PublishInfo,
r#"
SELECT
aw.publish_namespace AS namespace,
awn.namespace,
apc.publish_name,
apc.view_id,
au.email AS publisher_email,
@ -442,51 +471,47 @@ pub async fn select_published_collab_info_for_view_ids<'a, E: Executor<'a, Datab
FROM af_published_collab apc
JOIN af_user au ON apc.published_by = au.uid
JOIN af_workspace aw ON apc.workspace_id = aw.workspace_id
JOIN af_workspace_namespace awn ON aw.workspace_id = awn.workspace_id AND awn.is_original = TRUE
WHERE apc.view_id = ANY($1);
"#,
view_ids,
)
.fetch_all(executor)
.fetch_all(pg_pool)
.await?;
if res.is_empty() {
return Ok(res);
}
if let Some(non_original_namespace) =
select_first_non_original_namespace(pg_pool, &res[0].namespace).await?
{
res.iter_mut().for_each(|info| {
info.namespace = non_original_namespace.clone();
});
}
Ok(res)
}
pub async fn select_published_collab_info<'a, E: Executor<'a, Database = Postgres>>(
executor: E,
pub async fn select_published_collab_info(
pg_pool: &PgPool,
view_id: &Uuid,
) -> Result<PublishInfo, AppError> {
let res = sqlx::query_as!(
PublishInfo,
r#"
SELECT
aw.publish_namespace AS namespace,
apc.publish_name,
apc.view_id,
au.email AS publisher_email,
apc.created_at AS publish_timestamp
FROM af_published_collab apc
JOIN af_user au ON apc.published_by = au.uid
JOIN af_workspace aw ON apc.workspace_id = aw.workspace_id
WHERE apc.view_id = $1;
"#,
view_id,
)
.fetch_one(executor)
.await?;
Ok(res)
select_published_collab_info_for_view_ids(pg_pool, &[*view_id])
.await?
.into_iter()
.next()
.ok_or(AppError::RecordNotFound(view_id.to_string()))
}
pub async fn select_all_published_collab_info<'a, E: Executor<'a, Database = Postgres>>(
executor: E,
pub async fn select_all_published_collab_info(
pg_pool: &PgPool,
workspace_id: &Uuid,
) -> Result<Vec<PublishInfo>, AppError> {
let res = sqlx::query_as!(
let mut res = sqlx::query_as!(
PublishInfo,
r#"
SELECT
aw.publish_namespace AS namespace,
awn.namespace,
apc.publish_name,
apc.view_id,
au.email AS publisher_email,
@ -494,16 +519,36 @@ pub async fn select_all_published_collab_info<'a, E: Executor<'a, Database = Pos
FROM af_published_collab apc
JOIN af_user au ON apc.published_by = au.uid
JOIN af_workspace aw ON apc.workspace_id = aw.workspace_id
JOIN af_workspace_namespace awn ON aw.workspace_id = awn.workspace_id AND awn.is_original = TRUE
WHERE apc.workspace_id = $1;
"#,
workspace_id,
)
.fetch_all(executor)
.fetch_all(pg_pool)
.await?;
use_non_orginal_namespace_if_possible(pg_pool, &mut res).await?;
Ok(res)
}
async fn use_non_orginal_namespace_if_possible(
pg_pool: &PgPool,
publish_infos: &mut [PublishInfo],
) -> Result<(), AppError> {
if publish_infos.is_empty() {
return Ok(());
}
if let Some(non_original_namespace) =
select_first_non_original_namespace(pg_pool, &publish_infos[0].namespace).await?
{
publish_infos.iter_mut().for_each(|info| {
info.namespace = non_original_namespace.clone();
});
}
Ok(())
}
pub async fn select_workspace_id_for_publish_namespace<'a, E: Executor<'a, Database = Postgres>>(
executor: E,
publish_namespace: &str,
@ -511,8 +556,8 @@ pub async fn select_workspace_id_for_publish_namespace<'a, E: Executor<'a, Datab
let res = sqlx::query!(
r#"
SELECT workspace_id
FROM af_workspace
WHERE publish_namespace = $1
FROM af_workspace_namespace
WHERE namespace = $1
"#,
publish_namespace,
)

148
libs/database/src/workspace.rs
View File

@ -1053,159 +1053,13 @@ pub async fn upsert_workspace_settings(
Ok(())
}
#[inline]
pub async fn select_workspace_publish_namespace_exists<'a, E: Executor<'a, Database = Postgres>>(
executor: E,
workspace_id: &Uuid,
namespace: &str,
) -> Result<bool, AppError> {
let res = sqlx::query_scalar!(
r#"
SELECT EXISTS(
SELECT 1
FROM af_workspace
WHERE workspace_id = $1
AND publish_namespace = $2
)
"#,
workspace_id,
namespace,
)
.fetch_one(executor)
.await?;
Ok(res.unwrap_or(false))
}
#[inline]
pub async fn update_workspace_publish_namespace<'a, E: Executor<'a, Database = Postgres>>(
executor: E,
workspace_id: &Uuid,
new_namespace: &str,
) -> Result<(), AppError> {
let res = sqlx::query!(
r#"
UPDATE af_workspace
SET publish_namespace = $1
WHERE workspace_id = $2
"#,
new_namespace,
workspace_id,
)
.execute(executor)
.await?;
if res.rows_affected() != 1 {
tracing::error!(
"Failed to update workspace publish namespace, workspace_id: {}, new_namespace: {}, rows_affected: {}",
workspace_id, new_namespace, res.rows_affected()
);
}
Ok(())
}
#[inline]
pub async fn select_workspace_publish_namespace<'a, E: Executor<'a, Database = Postgres>>(
executor: E,
workspace_id: &Uuid,
) -> Result<String, AppError> {
let res = sqlx::query_scalar!(
r#"
SELECT publish_namespace
FROM af_workspace
WHERE workspace_id = $1
"#,
workspace_id,
)
.fetch_one(executor)
.await?;
Ok(res)
}
#[inline]
pub async fn select_publish_collab_meta<'a, E: Executor<'a, Database = Postgres>>(
executor: E,
publish_namespace: &str,
publish_name: &str,
) -> Result<serde_json::Value, AppError> {
let res = sqlx::query!(
r#"
SELECT metadata
FROM af_published_collab
WHERE workspace_id = (SELECT workspace_id FROM af_workspace WHERE publish_namespace = $1)
AND publish_name = $2
"#,
publish_namespace,
publish_name,
)
.fetch_one(executor)
.await?;
let metadata: serde_json::Value = res.metadata;
Ok(metadata)
}
#[inline]
pub async fn delete_published_collabs<'a, E: Executor<'a, Database = Postgres>>(
executor: E,
workspace_id: &Uuid,
view_ids: &[Uuid],
) -> Result<(), AppError> {
let res = sqlx::query!(
r#"
DELETE FROM af_published_collab
WHERE workspace_id = $1
AND view_id = ANY($2)
"#,
workspace_id,
view_ids,
)
.execute(executor)
.await?;
if res.rows_affected() != view_ids.len() as u64 {
tracing::error!(
"Failed to delete published collabs, workspace_id: {}, view_ids: {:?}, rows_affected: {}",
workspace_id,
view_ids,
res.rows_affected()
);
}
Ok(())
}
#[inline]
pub async fn select_published_collab_blob<'a, E: Executor<'a, Database = Postgres>>(
executor: E,
publish_namespace: &str,
publish_name: &str,
) -> Result<Vec<u8>, AppError> {
let res = sqlx::query_scalar!(
r#"
SELECT blob
FROM af_published_collab
WHERE workspace_id = (SELECT workspace_id FROM af_workspace WHERE publish_namespace = $1)
AND publish_name = $2
"#,
publish_namespace,
publish_name,
)
.fetch_one(executor)
.await?;
Ok(res)
}
pub async fn select_owner_of_published_collab<'a, E: Executor<'a, Database = Postgres>>(
executor: E,
view_id: &Uuid,
) -> Result<Uuid, AppError> {
let res = sqlx::query!(
r#"
SELECT
af.uuid
SELECT af.uuid
FROM af_published_collab apc
JOIN af_user af ON af.uid = apc.published_by
WHERE view_id = $1

10
migrations/20241101063559_af_workspace_namespace.sql
View File

@ -7,11 +7,11 @@ ALTER TABLE af_workspace DROP CONSTRAINT af_workspace_publish_namespace_key;
-- Table to store user defined namespace for workspace
CREATE TABLE IF NOT EXISTS af_workspace_namespace (
namespace TEXT NOT NULL PRIMARY KEY,
workspace_id UUID NOT NULL,
is_original BOOLEAN NOT NULL,
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
namespace TEXT NOT NULL PRIMARY KEY,
workspace_id UUID NOT NULL,
default_view_id UUID,
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (workspace_id) REFERENCES af_workspace (workspace_id) ON DELETE CASCADE
);

14
src/api/workspace.rs
View File

@ -1190,9 +1190,17 @@ async fn put_publish_namespace_handler(
.workspace_access_control
.enforce_role(&uid, &workspace_id.to_string(), AFRole::Owner)
.await?;
let new_namespace = payload.into_inner().new_namespace;
biz::workspace::publish::set_workspace_namespace(&state.pg_pool, &workspace_id, &new_namespace)
.await?;
let UpdatePublishNamespace {
old_namespace,
new_namespace,
} = payload.into_inner();
biz::workspace::publish::set_workspace_namespace(
&state.pg_pool,
&workspace_id,
&old_namespace,
&new_namespace,
)
.await?;
Ok(Json(AppResponse::Ok()))
}

37
src/biz/workspace/publish.rs
View File

@ -3,8 +3,9 @@ use database::{
collab::GetCollabOrigin,
publish::{
select_all_published_collab_info, select_default_published_view_id,
select_default_published_view_id_for_namespace, update_published_collabs,
update_workspace_default_publish_view, update_workspace_default_publish_view_set_null,
select_default_published_view_id_for_namespace, select_workspace_publish_namespaces,
update_published_collabs, update_workspace_default_publish_view,
update_workspace_default_publish_view_set_null,
},
workspace::{select_publish_name_exists, select_view_id_from_publish_name},
};
@ -29,8 +30,7 @@ use database::{
select_published_collab_blob, select_published_collab_info,
select_published_collab_workspace_view_id, select_published_data_for_view_id,
select_published_metadata_for_view_id, select_user_is_collab_publisher_for_all_views,
select_workspace_publish_namespace, select_workspace_publish_namespace_exists,
update_workspace_publish_namespace,
select_workspace_publish_namespace_exists, update_non_orginal_workspace_publish_namespace,
},
workspace::select_user_is_workspace_owner,
};
@ -88,6 +88,7 @@ fn get_collab_s3_key(workspace_id: &Uuid, view_id: &Uuid) -> String {
pub async fn set_workspace_namespace(
pg_pool: &PgPool,
workspace_id: &Uuid,
old_namespace: &str,
new_namespace: &str,
) -> Result<(), AppError> {
check_workspace_namespace(new_namespace).await?;
@ -96,7 +97,13 @@ pub async fn set_workspace_namespace(
"publish namespace is already taken".to_string(),
));
};
update_workspace_publish_namespace(pg_pool, workspace_id, new_namespace).await?;
update_non_orginal_workspace_publish_namespace(
pg_pool,
workspace_id,
old_namespace,
new_namespace,
)
.await?;
Ok(())
}
@ -165,7 +172,25 @@ pub async fn get_workspace_publish_namespace(
pg_pool: &PgPool,
workspace_id: &Uuid,
) -> Result<String, AppError> {
select_workspace_publish_namespace(pg_pool, workspace_id).await
let mut ws_namespaces = select_workspace_publish_namespaces(pg_pool, workspace_id).await?;
match ws_namespaces.len() {
0 => Err(AppError::RecordNotFound(format!(
"No publish namespace found for workspace_id: {}",
workspace_id
))),
1 => Ok(ws_namespaces.remove(0).namespace),
_ => {
for ws_namespace in ws_namespaces {
if !ws_namespace.is_original {
return Ok(ws_namespace.namespace);
}
}
Err(AppError::RecordNotFound(format!(
"Cannot find non-original publish namespace for workspace_id: {}",
workspace_id
)))
},
}
}
pub async fn list_collab_publish_info(

30
tests/workspace/publish.rs
View File

@ -39,8 +39,8 @@ async fn test_set_publish_namespace_set() {
.unwrap();
}
let namespace = uuid::Uuid::new_v4().to_string();
c.set_workspace_publish_namespace(&workspace_id.to_string(), &namespace)
let new_namespace = uuid::Uuid::new_v4().to_string();
c.set_workspace_publish_namespace(&workspace_id.to_string(), new_namespace.clone())
.await
.unwrap();
@ -49,7 +49,7 @@ async fn test_set_publish_namespace_set() {
let (c2, _user) = generate_unique_registered_user_client().await;
let workspace_id_2 = get_first_workspace_string(&c2).await;
let err = c2
.set_workspace_publish_namespace(&workspace_id_2.to_string(), &namespace)
.set_workspace_publish_namespace(&workspace_id_2.to_string(), new_namespace.clone())
.await
.unwrap_err();
assert_eq!(
@ -63,7 +63,7 @@ async fn test_set_publish_namespace_set() {
{
// cannot set the same namespace
let err = c
.set_workspace_publish_namespace(&workspace_id.to_string(), &namespace)
.set_workspace_publish_namespace(&workspace_id.to_string(), new_namespace.clone())
.await
.err()
.unwrap();
@ -74,10 +74,10 @@ async fn test_set_publish_namespace_set() {
err
);
}
let new_namespace_2 = uuid::Uuid::new_v4().to_string();
{
// can replace the namespace
let namespace = uuid::Uuid::new_v4().to_string();
c.set_workspace_publish_namespace(&workspace_id.to_string(), &namespace)
c.set_workspace_publish_namespace(&workspace_id.to_string(), new_namespace_2.clone())
.await
.unwrap();
@ -85,12 +85,12 @@ async fn test_set_publish_namespace_set() {
.get_workspace_publish_namespace(&workspace_id.to_string())
.await
.unwrap();
assert_eq!(got_namespace, namespace);
assert_eq!(got_namespace, new_namespace_2);
}
{
// cannot set namespace with invalid chars
let err = c
.set_workspace_publish_namespace(&workspace_id.to_string(), "/|(*&)(&#@!") // invalid chars
.set_workspace_publish_namespace(&workspace_id.to_string(), "/|(*&)(&#@!".to_string()) // invalid chars
.await
.err()
.unwrap();
@ -108,7 +108,7 @@ async fn test_publish_doc() {
let (c, _user) = generate_unique_registered_user_client().await;
let workspace_id = get_first_workspace_string(&c).await;
let my_namespace = uuid::Uuid::new_v4().to_string();
c.set_workspace_publish_namespace(&workspace_id.to_string(), &my_namespace)
c.set_workspace_publish_namespace(&workspace_id.to_string(), my_namespace.clone())
.await
.unwrap();
@ -239,7 +239,7 @@ async fn test_publish_doc() {
.get_published_collab_info(&view_id_1)
.await
.unwrap();
assert_eq!(publish_info.namespace, Some(my_namespace.clone()));
assert_eq!(publish_info.namespace, my_namespace.clone());
assert_eq!(publish_info.publish_name, publish_name_1);
assert_eq!(publish_info.view_id, view_id_1);
@ -253,7 +253,7 @@ async fn test_publish_doc() {
.get_published_collab_info(&view_id_2)
.await
.unwrap();
assert_eq!(publish_info.namespace, Some(my_namespace.clone()));
assert_eq!(publish_info.namespace, my_namespace.clone());
assert_eq!(publish_info.publish_name, publish_name_2);
assert_eq!(publish_info.view_id, view_id_2);
@ -457,7 +457,7 @@ async fn test_publish_comments() {
let workspace_id = get_first_workspace_string(&page_owner_client).await;
let published_view_namespace = uuid::Uuid::new_v4().to_string();
page_owner_client
.set_workspace_publish_namespace(&workspace_id.to_string(), &published_view_namespace)
.set_workspace_publish_namespace(&workspace_id.to_string(), published_view_namespace)
.await
.unwrap();
@ -653,7 +653,7 @@ async fn test_excessive_comment_length() {
let workspace_id = get_first_workspace_string(&client).await;
let published_view_namespace = uuid::Uuid::new_v4().to_string();
client
.set_workspace_publish_namespace(&workspace_id.to_string(), &published_view_namespace)
.set_workspace_publish_namespace(&workspace_id.to_string(), published_view_namespace)
.await
.unwrap();
@ -689,7 +689,7 @@ async fn test_publish_reactions() {
let workspace_id = get_first_workspace_string(&page_owner_client).await;
let published_view_namespace = uuid::Uuid::new_v4().to_string();
page_owner_client
.set_workspace_publish_namespace(&workspace_id.to_string(), &published_view_namespace)
.set_workspace_publish_namespace(&workspace_id.to_string(), published_view_namespace)
.await
.unwrap();
@ -813,7 +813,7 @@ async fn test_publish_load_test() {
let (c, _user) = generate_unique_registered_user_client().await;
let workspace_id = get_first_workspace_string(&c).await;
let my_namespace = uuid::Uuid::new_v4().to_string();
c.set_workspace_publish_namespace(&workspace_id.to_string(), &my_namespace)
c.set_workspace_publish_namespace(&workspace_id.to_string(), my_namespace)
.await
.unwrap();

13
tests/workspace/template.rs
View File

@ -215,7 +215,7 @@ async fn test_template_crud() {
let workspace_id = get_first_workspace_string(&authorized_client).await;
let published_view_namespace = uuid::Uuid::new_v4().to_string();
authorized_client
.set_workspace_publish_namespace(&workspace_id.to_string(), &published_view_namespace)
.set_workspace_publish_namespace(&workspace_id.to_string(), published_view_namespace.clone())
.await
.unwrap();
let published_view_ids: Vec<Uuid> = (0..4).map(|_| Uuid::new_v4()).collect();
@ -362,13 +362,8 @@ async fn test_template_crud() {
assert!(view_ids.contains(&published_view_ids[2]));
assert!(view_ids.contains(&published_view_ids[3]));
assert_eq!(
templates[0]
.publish_info
.namespace
.as_ref()
.unwrap()
.to_string(),
published_view_namespace.clone()
templates[0].publish_info.namespace,
published_view_namespace
);
let featured_templates = guest_client
@ -408,7 +403,7 @@ async fn test_template_crud() {
published_view_ids[0]
);
assert_eq!(
template.publish_info.namespace.unwrap(),
template.publish_info.namespace,
published_view_namespace.clone()
);