linting, tenant slug -> name

backend/tests/auth_flow.rs

@@ -33,7 +33,8 @@ struct ErrorResponse {
 
 #[derive(Deserialize)]
 struct LoginTenant {
-    slug: String,
+    id: Uuid,
+    name: String,
 }
 
 #[derive(Deserialize)]
@@ -51,7 +52,7 @@ struct TenantSelectionResponse {
 #[derive(Deserialize)]
 struct TenantSummary {
     id: Uuid,
-    slug: String,
+    name: String,
 }
 
 #[tokio::test]
@@ -116,7 +117,7 @@ async fn signup_creates_user_tenant_and_membership() -> Result<()> {
             .first(conn)?;
 
         let tenant: backend::models::Tenant = tenants::table
-            .filter(tenants::slug.eq("signup-user"))
+            .filter(tenants::name.eq("signup-user"))
             .first(conn)?;
 
         assert_eq!(tenant.status, TenantStatus::Creating);
@@ -419,7 +420,7 @@ async fn refresh_rotates_refresh_token() -> Result<()> {
     let new_cookie = extract_refresh_cookie(response.headers())?;
     let body = body_to_vec(response.into_body()).await?;
     let refreshed: LoginResponse = serde_json::from_slice(&body)?;
-    assert_eq!(refreshed.tenant.slug, login.tenant.slug);
+    assert_eq!(refreshed.tenant.name, login.tenant.name);
 
     let me_response = app
         .get("/api/auth/me", Some(&refreshed.access_token))
@@ -492,14 +493,14 @@ async fn login_returns_tenant_selection_when_multiple_memberships() -> Result<()
     let password = "multipass";
     let user_id = app.insert_user("multipass", password, "admin").await?;
 
-    let secondary_slug = "secondary".to_string();
-    let slug_for_insert = secondary_slug.clone();
+    let secondary_name = "secondary".to_string();
+    let name_for_insert = secondary_name.clone();
     let secondary_id = Uuid::new_v4();
     app.with_conn(move |conn| {
         diesel::insert_into(tenants::table)
             .values((
                 tenants::id.eq(secondary_id),
-                tenants::slug.eq(&slug_for_insert),
+                tenants::name.eq(&name_for_insert),
                 tenants::status.eq(TenantStatus::Active),
             ))
             .execute(conn)?;
@@ -526,7 +527,7 @@ async fn login_returns_tenant_selection_when_multiple_memberships() -> Result<()
     let secondary = selection
         .tenants
         .iter()
-        .find(|tenant| tenant.slug == secondary_slug)
+        .find(|tenant| tenant.name == secondary_name)
         .map(|t| t.id)
         .context("secondary tenant missing from selection")?;
 
@@ -541,7 +542,7 @@ async fn login_returns_tenant_selection_when_multiple_memberships() -> Result<()
     let session_cookie = extract_refresh_cookie(select_response.headers())?;
     let select_body = body_to_vec(select_response.into_body()).await?;
     let login: LoginResponse = serde_json::from_slice(&select_body)?;
-    assert_eq!(login.tenant.slug, secondary_slug);
+    assert_eq!(login.tenant.name, secondary_name);
 
     let me_response = app.get("/api/auth/me", Some(&login.access_token)).await?;
     assert_eq!(me_response.status(), StatusCode::OK);

backend/tests/common/mod.rs

@@ -140,7 +140,7 @@ impl TestApp {
             s3_bucket: "test-bucket".to_string(),
             quickwit_endpoint: None,
             quickwit_index: None,
-            default_tenant_slug: "admin".to_string(),
+            default_tenant_name: "admin".to_string(),
             worker_max_document_bytes: 200 * 1024 * 1024,
             webauthn_rp_id: Some("localhost".to_string()),
             webauthn_origin: Some("http://localhost".to_string()),
@@ -193,7 +193,7 @@ impl TestApp {
         let tenant = self
             .state
             .tenants
-            .get_by_slug(&self.state.config.default_tenant_slug)
+            .get_by_name(&self.state.config.default_tenant_name)
             .map_err(|err| anyhow!("default tenant not found: {:?}", err))?;
         let root = tenant
             .storage_root
@@ -208,7 +208,7 @@ impl TestApp {
         let tenant_id = self
             .state
             .tenants
-            .tenant_id_for_slug(&self.state.config.default_tenant_slug)
+            .tenant_id_for_name(&self.state.config.default_tenant_name)
             .map_err(|err| anyhow!("default tenant not found: {:?}", err))?;
         self.with_conn(move |conn| {
             let password_hash = hash_password(&password)?;
@@ -264,13 +264,13 @@ impl TestApp {
     }
 
     async fn ensure_default_tenant(&self) -> Result<Uuid> {
-        let slug_value = self.state.config.default_tenant_slug.clone();
+        let name_value = self.state.config.default_tenant_name.clone();
         let quickwit_enabled = self.state.config.quickwit_endpoint.is_some();
         self.with_conn(move |conn| {
             use backend::schema::tenants::dsl as tenants_dsl;
 
             let existing = tenants_dsl::tenants
-                .filter(tenants_dsl::slug.eq(&slug_value))
+                .filter(tenants_dsl::name.eq(&name_value))
                 .first::<Tenant>(conn)
                 .optional()
                 .context("failed to load default tenant")?;
@@ -302,7 +302,7 @@ impl TestApp {
                 diesel::insert_into(tenants_dsl::tenants)
                     .values((
                         tenants_dsl::id.eq(new_id),
-                        tenants_dsl::slug.eq(&slug_value),
+                        tenants_dsl::name.eq(&name_value),
                         tenants_dsl::storage_root.eq(Some(root)),
                         tenants_dsl::quickwit_index.eq(quickwit_value),
                         tenants_dsl::status.eq(TenantStatus::Active),
@@ -352,7 +352,7 @@ impl TestApp {
         #[derive(Deserialize)]
         struct TenantSummary {
             id: Uuid,
-            _slug: String,
+            name: String,
         }
 
         #[derive(Deserialize)]

backend/tests/tags_flow.rs

@@ -211,7 +211,7 @@ async fn tags_are_isolated_between_tenants() -> Result<()> {
         diesel::insert_into(tenants_dsl::tenants)
             .values((
                 tenants_dsl::id.eq(tenant_b_id),
-                tenants_dsl::slug.eq("tenant-b"),
+                tenants_dsl::name.eq("tenant-b"),
                 tenants_dsl::storage_root.eq(Some(storage_root)),
                 tenants_dsl::status.eq(TenantStatus::Active),
             ))