update rust deps

backend/tests/api_tokens_flow.rs

@@ -1,15 +1,16 @@
-mod common;
-
-use anyhow::Result;
+use anyhow::{Context, Result};
 use axum::body::Body;
 use axum::http::{header, Method, Request, StatusCode};
 use base64::engine::general_purpose::STANDARD as BASE64;
 use base64::Engine;
-use common::{acquire_db_lock, body_to_vec, TestApp, TestUserRole};
 use diesel::prelude::*;
-use papercrate::models::ApiToken;
+use diesel::OptionalExtension;
+use papercrate::auth::capability_sets;
+use papercrate::models::{ApiCapability, ApiToken};
 use papercrate::routes::webdav;
 use papercrate::schema::api_tokens;
+use papercrate::schema::capability_sets::dsl as capability_sets_dsl;
+use papercrate::test_support::{acquire_db_lock, body_to_vec, TestApp, TestUserRole};
 use serde::Deserialize;
 use serde_json::json;
 use tower::ServiceExt;
@@ -59,12 +60,6 @@ struct TenantView {
     name: String,
 }
 
-#[derive(Debug, Deserialize)]
-struct CapabilitySetSummary {
-    id: Uuid,
-    slug: String,
-}
-
 #[tokio::test]
 async fn api_token_crud_flow() -> Result<()> {
     let _guard = acquire_db_lock().await;
@@ -356,46 +351,42 @@ async fn ensure_capability_set_slug(
     slug: &str,
     capabilities: &[&str],
 ) -> Result<Uuid> {
-    if let Some(existing) = find_capability_set_slug(app, access_token, slug).await? {
-        return Ok(existing);
-    }
+    let claims = app
+        .state
+        .jwt
+        .verify_token(access_token)
+        .context("failed to decode access token claims")?;
+    let tenant_id = claims.tenant_id;
+    let slug = slug.to_string();
+    let desired_capabilities = capabilities
+        .iter()
+        .map(|value| {
+            value
+                .parse::<ApiCapability>()
+                .map_err(|err| anyhow::anyhow!("invalid capability '{value}': {err}"))
+        })
+        .collect::<Result<Vec<_>>>()?;
 
-    let response = app
-        .post_json(
-            "/api/capability-sets",
-            &json!({
-                "slug": slug,
-                "capabilities": capabilities,
-            }),
-            Some(access_token),
-        )
-        .await?;
-    assert_eq!(response.status(), StatusCode::CREATED);
-    let body = body_to_vec(response.into_body()).await?;
-    let summary: CapabilitySetSummary = serde_json::from_slice(&body)?;
-    Ok(summary.id)
-}
+    let caps_for_insert = desired_capabilities.clone();
+    app.with_conn(move |conn| {
+        if let Some(existing) = capability_sets_dsl::capability_sets
+            .filter(capability_sets_dsl::tenant_id.eq(tenant_id))
+            .filter(capability_sets_dsl::slug.eq(&slug))
+            .select(capability_sets_dsl::id)
+            .first::<Uuid>(conn)
+            .optional()?
+        {
+            return Ok(existing);
+        }
 
-async fn find_capability_set_slug(
-    app: &TestApp,
-    access_token: &str,
-    slug: &str,
-) -> Result<Option<Uuid>> {
-    let sets = list_capability_sets(app, access_token).await?;
-    Ok(sets
-        .into_iter()
-        .find(|set| set.slug == slug)
-        .map(|set| set.id))
-}
-
-async fn list_capability_sets(
-    app: &TestApp,
-    access_token: &str,
-) -> Result<Vec<CapabilitySetSummary>> {
-    let response = app.get("/api/capability-sets", Some(access_token)).await?;
-    assert_eq!(response.status(), StatusCode::OK);
-    let body = body_to_vec(response.into_body()).await?;
-    Ok(serde_json::from_slice(&body)?)
+        let created =
+            capability_sets::create_capability_set(conn, tenant_id, &slug, caps_for_insert)
+                .map_err(|err| {
+                    anyhow::anyhow!("failed to create capability set '{slug}': {err:?}")
+                })?;
+        Ok(created.id)
+    })
+    .await
 }
 async fn exchange_token(app: &TestApp, api_token: &str) -> Result<LoginResponseView> {
     let response = app