Skip to main content

yang_base/action/
tenant.rs

1//! 请求租户解析中间件。
2//!
3//! 客户端提供的租户 ID 只是不可信候选;应用实现的 [`TenantResolver`] 必须结合
4//! 已认证用户、租户成员关系和业务状态完成校验,再返回可信 [`TenantResolution`]。
5
6use super::{
7    ActionContext, ActorContext, ApiResponse, SystemTenantCapability, TenantContext, TenantId, User,
8};
9use crate::error::BaseError;
10use crate::router::{Middleware, MiddlewareRole, Next};
11use async_trait::async_trait;
12
13/// 默认租户候选请求头。
14pub const TENANT_ID_HEADER: &str = "x-tenant-id";
15
16/// 可信 resolver 的互斥解析结果。
17///
18/// 普通租户始终携带不可选 [`TenantContext`];系统访问携带独立且绑定 actor 的
19/// [`SystemTenantCapability`]。代数和类型消除了 `Option<TenantId> + bool` 的非法状态。
20#[derive(Debug, Clone, Copy, PartialEq, Eq)]
21pub enum TenantResolution {
22    /// 范围化普通租户访问。
23    Tenant(TenantContext),
24    /// 显式系统级访问。
25    System(SystemTenantCapability),
26}
27
28impl TenantResolution {
29    /// 在可信 resolver 中为已认证 system 角色签发系统 capability。
30    pub fn system_for(user: &User) -> Result<Self, BaseError> {
31        if !user.has_role("system") {
32            return Err(BaseError::PermissionDenied(
33                "只有已认证 system 角色可获授系统租户 capability".to_string(),
34            ));
35        }
36        Ok(Self::System(SystemTenantCapability::issue(
37            ActorContext::new(user.id),
38        )))
39    }
40}
41
42impl From<TenantContext> for TenantResolution {
43    fn from(value: TenantContext) -> Self {
44        Self::Tenant(value)
45    }
46}
47
48/// 将不可信租户候选解析为可信请求租户上下文。
49///
50/// `requested` 仅表示客户端想访问的租户,不能证明当前用户属于该租户。实现者必须
51/// 依据已认证用户和服务端事实源校验成员关系;若允许系统级绕过,也必须在这里检查
52/// 独立的系统权限后显式返回 [`TenantResolution::System`]。
53#[async_trait]
54pub trait TenantResolver: Send + Sync + 'static {
55    /// 解析当前请求的可信租户上下文。
56    ///
57    /// `None` 表示客户端未指定租户;实现者可选择安全的默认租户,也可拒绝请求。
58    async fn resolve(
59        &self,
60        context: &ActionContext,
61        requested: Option<TenantId>,
62    ) -> Result<TenantResolution, BaseError>;
63
64    /// 解析租户并可同时写入仅在本次请求有效的服务端 capability。
65    ///
66    /// 默认实现保持既有 resolver 行为。需要把同一次事实源查询的附加结果交给后续
67    /// middleware 的实现可以覆盖此方法,通过 [`ActionContext::request_context`] 写入
68    /// 类型化值。附加 capability 只能作为事务前快速拒绝依据,不能替代写事务内的
69    /// 最终授权复核。
70    async fn resolve_with_context(
71        &self,
72        context: &mut ActionContext,
73        requested: Option<TenantId>,
74    ) -> Result<TenantResolution, BaseError> {
75        self.resolve(context, requested).await
76    }
77}
78
79/// 在 Action 派发前解析并注入可信租户上下文。
80///
81/// 中间件读取 [`TENANT_ID_HEADER`],只接受正整数。它不会自行信任该值,而是把候选
82/// 交给 [`TenantResolver`];resolver 成功返回后才写入 [`ActionContext`]。
83///
84/// 注册顺序必须放在身份认证中间件之后,使 resolver 能读取
85/// [`ActionContext::authenticated_user`]。如果 resolver 允许匿名租户,它也必须显式
86/// 实现该策略。
87pub struct TenantResolverMiddleware<R> {
88    resolver: R,
89}
90
91impl<R> TenantResolverMiddleware<R>
92where
93    R: TenantResolver,
94{
95    /// 创建租户解析中间件。
96    pub fn new(resolver: R) -> Self {
97        Self { resolver }
98    }
99}
100
101#[async_trait]
102impl<R> Middleware for TenantResolverMiddleware<R>
103where
104    R: TenantResolver,
105{
106    fn role(&self) -> MiddlewareRole {
107        MiddlewareRole::TenantResolution
108    }
109
110    async fn handle(
111        &self,
112        mut context: ActionContext,
113        next: Next<'_>,
114    ) -> Result<ApiResponse, BaseError> {
115        let requested = requested_tenant(&context)?;
116        let resolution = self
117            .resolver
118            .resolve_with_context(&mut context, requested)
119            .await?;
120        let context = match resolution {
121            TenantResolution::Tenant(tenant) => {
122                tracing::Span::current().record("tenant_scope", "tenant");
123                tracing::Span::current().record("tenant_id", tenant.id().get());
124                context.with_tenant(tenant)
125            }
126            TenantResolution::System(capability) => {
127                tracing::Span::current().record("tenant_scope", "system");
128                context.with_system_tenant(capability)
129            }
130        };
131        next.run(context).await
132    }
133}
134
135fn requested_tenant(context: &ActionContext) -> Result<Option<TenantId>, BaseError> {
136    let Some(raw) = context.request.get_header(TENANT_ID_HEADER) else {
137        return Ok(None);
138    };
139    let value = raw.parse::<i64>().map_err(|_| {
140        BaseError::ParamInvalid(
141            TENANT_ID_HEADER.to_string(),
142            "租户 ID 必须是正整数".to_string(),
143        )
144    })?;
145    if value <= 0 {
146        return Err(BaseError::ParamInvalid(
147            TENANT_ID_HEADER.to_string(),
148            "租户 ID 必须是正整数".to_string(),
149        ));
150    }
151    Ok(Some(TenantId::new(value)))
152}
153
154#[cfg(test)]
155mod tests {
156    use super::*;
157    use crate::action::{ContextKey, Request, TypedHandler, User};
158    use crate::definition::{
159        ActionName, ActionRef, ActionSpec, AddonName, AddonSpec, AppBuilder, HttpMethod,
160        ModuleName, ModuleSpec, RouteSpec,
161    };
162    use crate::tools::ToolsBuilder;
163    use async_trait::async_trait;
164    use schemars::JsonSchema;
165    use serde::{Deserialize, Serialize};
166    use std::sync::Arc;
167    use yang_base_derive::Action;
168
169    #[derive(Debug, Default, Deserialize, JsonSchema)]
170    #[serde(deny_unknown_fields)]
171    struct EmptyInput {}
172
173    #[derive(Debug, Serialize, JsonSchema)]
174    struct TenantProbeOutput {
175        tenant_id: Option<i64>,
176        system_actor_id: Option<i64>,
177        resolver_evidence: Option<i64>,
178    }
179
180    const RESOLVER_EVIDENCE: ContextKey<i64> = ContextKey::new("resolver_evidence");
181
182    #[derive(Action)]
183    #[action(name = "tenant_probe", display_name = "租户探针")]
184    struct TenantProbe;
185
186    #[async_trait]
187    impl TypedHandler for TenantProbe {
188        type Input = EmptyInput;
189        type Output = TenantProbeOutput;
190
191        async fn handle(
192            &self,
193            mut context: ActionContext,
194            _input: Self::Input,
195        ) -> Result<Self::Output, BaseError> {
196            let resolver_evidence = context.request_context().get(RESOLVER_EVIDENCE).copied();
197            match context.tenant() {
198                Ok(tenant) => Ok(TenantProbeOutput {
199                    tenant_id: Some(tenant.id().get()),
200                    system_actor_id: None,
201                    resolver_evidence,
202                }),
203                Err(_) => Ok(TenantProbeOutput {
204                    tenant_id: None,
205                    system_actor_id: Some(context.system_tenant()?.actor().user_id()),
206                    resolver_evidence,
207                }),
208            }
209        }
210    }
211
212    struct MembershipResolver;
213
214    #[async_trait]
215    impl TenantResolver for MembershipResolver {
216        async fn resolve(
217            &self,
218            context: &ActionContext,
219            requested: Option<TenantId>,
220        ) -> Result<TenantResolution, BaseError> {
221            let user = context
222                .authenticated_user()
223                .ok_or_else(|| BaseError::Unauthorized("租户解析需要已认证用户".to_string()))?;
224            if user.has_role("system") {
225                return TenantResolution::system_for(user);
226            }
227
228            let tenant = requested.unwrap_or_else(|| TenantId::new(10));
229            if user.id == 7 && tenant == TenantId::new(10) {
230                Ok(TenantContext::new(tenant).into())
231            } else {
232                Err(BaseError::PermissionDenied(format!(
233                    "用户无权访问租户 {}",
234                    tenant.get()
235                )))
236            }
237        }
238
239        async fn resolve_with_context(
240            &self,
241            context: &mut ActionContext,
242            requested: Option<TenantId>,
243        ) -> Result<TenantResolution, BaseError> {
244            let resolution = self.resolve(context, requested).await?;
245            if matches!(resolution, TenantResolution::Tenant(_)) {
246                context.request_context().insert(RESOLVER_EVIDENCE, 42);
247            }
248            Ok(resolution)
249        }
250    }
251
252    fn test_app() -> crate::definition::BuiltApp {
253        let module_name = ModuleName::new("org.tenant").expect("测试 Module 名称应有效");
254        let module = ModuleSpec::new(module_name)
255            .middleware(TenantResolverMiddleware::new(MembershipResolver))
256            .action(
257                ActionSpec::new(
258                    ActionName::new("tenant_probe").expect("测试 Action 名称应有效"),
259                    RouteSpec::new(
260                        HttpMethod::Get,
261                        "/api/v1/org/tenant/probe",
262                        "org.tenant.tenant_probe",
263                    ),
264                ),
265                TenantProbe,
266            );
267        let tools = Arc::new(ToolsBuilder::new().build().expect("测试 Tools 应构建成功"));
268        AppBuilder::new()
269            .addon(
270                AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
271                    .module(module),
272            )
273            .build(tools)
274            .expect("租户解析测试应用应构建成功")
275    }
276
277    fn probe_handle(app: &crate::definition::BuiltApp) -> crate::definition::ActionHandle {
278        app.registry()
279            .resolve(&ActionRef::new(
280                ModuleName::new("org.tenant").expect("测试 Module 名称应有效"),
281                ActionName::new("tenant_probe").expect("测试 Action 名称应有效"),
282            ))
283            .expect("租户探针应已注册")
284    }
285
286    fn tenant_response(response: ApiResponse) -> (Option<i64>, Option<i64>) {
287        let data = response.data.expect("租户探针应返回 JSON data");
288        (
289            data.get("tenant_id").and_then(serde_json::Value::as_i64),
290            data.get("system_actor_id")
291                .and_then(serde_json::Value::as_i64),
292        )
293    }
294
295    async fn dispatch_as(
296        app: &crate::definition::BuiltApp,
297        request: Request,
298        user: Option<User>,
299    ) -> Result<ApiResponse, BaseError> {
300        let mut context = app.context(request);
301        if let Some(user) = user {
302            context = context.with_user(user);
303        }
304        app.dispatch_context(probe_handle(app), context).await
305    }
306
307    #[tokio::test]
308    async fn resolver_accepts_authorized_candidate_and_safe_default() {
309        let app = test_app();
310        let user = User::new(7, "member");
311
312        let selected = dispatch_as(
313            &app,
314            Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "10"),
315            Some(user.clone()),
316        )
317        .await
318        .expect("成员应能选择所属租户");
319        assert_eq!(
320            selected
321                .data
322                .as_ref()
323                .and_then(|data| data.get("resolver_evidence"))
324                .and_then(serde_json::Value::as_i64),
325            Some(42),
326            "resolver 同一次事实查询写入的请求 capability 必须到达后续 Action"
327        );
328        assert_eq!(tenant_response(selected), (Some(10), None));
329
330        let defaulted = dispatch_as(&app, Request::new(serde_json::json!({})), Some(user))
331            .await
332            .expect("resolver 应能安全选择服务端默认租户");
333        assert_eq!(tenant_response(defaulted), (Some(10), None));
334    }
335
336    #[tokio::test]
337    async fn resolver_rejects_invalid_cross_tenant_and_unauthenticated_requests() {
338        let app = test_app();
339        let user = User::new(7, "member");
340
341        for invalid in ["", "system", "0", "-1"] {
342            let result = dispatch_as(
343                &app,
344                Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, invalid),
345                Some(user.clone()),
346            )
347            .await;
348            assert!(matches!(
349                result,
350                Err(BaseError::ParamInvalid(field, _)) if field == TENANT_ID_HEADER
351            ));
352        }
353
354        let cross_tenant = dispatch_as(
355            &app,
356            Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "20"),
357            Some(user),
358        )
359        .await;
360        assert!(matches!(
361            cross_tenant,
362            Err(BaseError::PermissionDenied(message)) if message.contains("租户 20")
363        ));
364
365        let unauthenticated = dispatch_as(
366            &app,
367            Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "10"),
368            None,
369        )
370        .await;
371        assert!(matches!(unauthenticated, Err(BaseError::Unauthorized(_))));
372    }
373
374    #[tokio::test]
375    async fn system_context_can_only_come_from_trusted_resolver() {
376        let app = test_app();
377        let system_user = User::new(1, "root").with_roles(["system"]);
378        assert!(matches!(
379            TenantResolution::system_for(&User::new(7, "member")),
380            Err(BaseError::PermissionDenied(_))
381        ));
382
383        let response = dispatch_as(&app, Request::new(serde_json::json!({})), Some(system_user))
384            .await
385            .expect("系统角色应由可信 resolver 映射为 system 上下文");
386        assert_eq!(tenant_response(response), (None, Some(1)));
387
388        let forged = dispatch_as(
389            &app,
390            Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "system"),
391            Some(User::new(7, "member")),
392        )
393        .await;
394        assert!(matches!(
395            forged,
396            Err(BaseError::ParamInvalid(field, _)) if field == TENANT_ID_HEADER
397        ));
398    }
399
400    /// I-6:真实 `TokenAuthMiddleware` → `TenantResolverMiddleware` 链路的组合测试。
401    ///
402    /// 不再用 `with_user` 绕过认证直接注入身份,而是让请求依次经过认证与租户
403    /// 两个中间件,锁定「认证必须先于租户注册」的协作语义与 fail-closed 行为。
404    /// 有效 Token 的成功注入路径依赖 Redis 撤销存储,由 `action::auth` 的
405    /// `#[ignore]` Docker 测试覆盖;本模块锁定无 Docker 环境下的链路行为。
406    #[cfg(feature = "token")]
407    mod token_auth_chain {
408        use super::*;
409        use crate::action::TokenAuthMiddleware;
410
411        /// 无撤销存储(未配置 cache)的测试 Tools。
412        fn chain_tools() -> Arc<crate::tools::Tools> {
413            Arc::new(
414                ToolsBuilder::new()
415                    .token(crate::token::TokenManager::new_symmetric(
416                        "tenant-chain-test-secret",
417                        jsonwebtoken::Algorithm::HS256,
418                        "test-issuer".to_string(),
419                        "test-audience".to_string(),
420                        3600,
421                        7200,
422                    ))
423                    .build()
424                    .expect("测试 Tools 应构建成功"),
425            )
426        }
427
428        fn chain_handle(
429            app: &crate::definition::BuiltApp,
430            module: &str,
431            action: &str,
432        ) -> crate::definition::ActionHandle {
433            app.registry()
434                .resolve(&ActionRef::new(
435                    ModuleName::new(module).expect("测试 Module 名称应有效"),
436                    ActionName::new(action).expect("测试 Action 名称应有效"),
437                ))
438                .expect("探针 Action 应已注册")
439        }
440
441        fn chain_access_token(app: &crate::definition::BuiltApp) -> String {
442            app.tools()
443                .token()
444                .expect("测试应用应配置 TokenManager")
445                .generate_access_token("user-7", serde_json::json!({}))
446                .expect("测试 Access Token 应生成成功")
447        }
448
449        /// 构造「认证 → 租户」链路应用:受保护的租户探针。
450        fn protected_chain_app() -> crate::definition::BuiltApp {
451            let module = ModuleSpec::new(
452                ModuleName::new("org.tenant_chain").expect("测试 Module 名称应有效"),
453            )
454            .middleware(TokenAuthMiddleware::new(|claims| {
455                User::new(7, claims.sub.clone())
456            }))
457            .middleware(TenantResolverMiddleware::new(MembershipResolver))
458            .action(
459                ActionSpec::new(
460                    ActionName::new("tenant_probe").expect("测试 Action 名称应有效"),
461                    RouteSpec::new(
462                        HttpMethod::Get,
463                        "/api/v1/org/tenant-chain/probe",
464                        "org.tenant_chain.tenant_probe",
465                    ),
466                ),
467                TenantProbe,
468            );
469            AppBuilder::new()
470                .addon(
471                    AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
472                        .module(module),
473                )
474                .build(chain_tools())
475                .expect("链路测试应用应构建成功")
476        }
477
478        #[test]
479        fn build_rejects_tenant_before_token_authentication() {
480            let module = ModuleSpec::new(
481                ModuleName::new("org.tenant_bad_order").expect("测试 Module 名称应有效"),
482            )
483            .middleware(TenantResolverMiddleware::new(MembershipResolver))
484            .middleware(TokenAuthMiddleware::new(|claims| {
485                User::new(7, claims.sub.clone())
486            }))
487            .action(
488                ActionSpec::new(
489                    ActionName::new("tenant_probe").expect("测试 Action 名称应有效"),
490                    RouteSpec::new(
491                        HttpMethod::Get,
492                        "/api/v1/org/tenant-bad-order/probe",
493                        "org.tenant_bad_order.tenant_probe",
494                    ),
495                ),
496                TenantProbe,
497            );
498            let error = AppBuilder::new()
499                .addon(
500                    AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
501                        .module(module),
502                )
503                .build(chain_tools())
504                .expect_err("租户解析先于认证必须在构建期失败");
505            assert!(matches!(
506                error,
507                crate::definition::BuildError::InvalidReference {
508                    kind: "Middleware order",
509                    ..
510                }
511            ));
512        }
513
514        /// 真实链路端到端:认证中间件先于租户中间件执行,任一环节失败即短路。
515        #[tokio::test]
516        async fn token_auth_runs_before_tenant_resolver_and_fails_closed() {
517            let app = protected_chain_app();
518            let handle = chain_handle(&app, "org.tenant_chain", "tenant_probe");
519
520            // 无 Authorization 头:认证中间件短路。若顺序相反(租户先执行),
521            // 报错会是 resolver 的「租户解析需要已认证用户」而非缺少 Token。
522            let missing = app
523                .dispatch(
524                    handle,
525                    Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "10"),
526                )
527                .await;
528            assert!(matches!(
529                missing,
530                Err(BaseError::Unauthorized(message)) if message.contains("Authorization Bearer Token")
531            ));
532
533            // 无效 Token:签名校验失败即短路,请求不会到达租户 resolver。
534            let invalid = app
535                .dispatch(
536                    handle,
537                    Request::new(serde_json::json!({}))
538                        .header("Authorization", "Bearer invalid-token")
539                        .header(TENANT_ID_HEADER, "10"),
540                )
541                .await;
542            assert!(matches!(invalid, Err(BaseError::TokenVerifyFailed(_))));
543
544            // 签名有效但未配置撤销存储:verify_token_checked 不降级跳过撤销检查,
545            // 以 RedisNotInitialized fail-closed,请求仍不会到达租户 resolver。
546            let token = chain_access_token(&app);
547            let no_store = app
548                .dispatch(
549                    handle,
550                    Request::new(serde_json::json!({}))
551                        .header("Authorization", format!("Bearer {token}"))
552                        .header(TENANT_ID_HEADER, "10"),
553                )
554                .await;
555            assert!(
556                matches!(no_store, Err(BaseError::RedisNotInitialized)),
557                "无撤销存储时不得降级放行: {no_store:?}"
558            );
559        }
560
561        /// 同时观察租户上下文与认证状态的公开探针。
562        #[derive(Debug, Serialize, JsonSchema)]
563        struct TenantAuthProbeOutput {
564            tenant_id: i64,
565            authenticated: bool,
566        }
567
568        #[derive(Action)]
569        #[action(name = "tenant_auth_probe", display_name = "租户认证探针", public)]
570        struct TenantAuthProbe;
571
572        #[async_trait]
573        impl TypedHandler for TenantAuthProbe {
574            type Input = EmptyInput;
575            type Output = TenantAuthProbeOutput;
576
577            async fn handle(
578                &self,
579                context: ActionContext,
580                _input: Self::Input,
581            ) -> Result<Self::Output, BaseError> {
582                let tenant = context.tenant()?;
583                Ok(TenantAuthProbeOutput {
584                    tenant_id: tenant.id().get(),
585                    authenticated: context.authenticated_user().is_some(),
586                })
587            }
588        }
589
590        /// 显式允许匿名的 resolver:匿名请求忽略客户端候选,落入服务端选择的
591        /// 访客默认租户;已认证成员沿用 MembershipResolver 的候选校验规则。
592        struct GuestOrMemberResolver;
593
594        #[async_trait]
595        impl TenantResolver for GuestOrMemberResolver {
596            async fn resolve(
597                &self,
598                context: &ActionContext,
599                requested: Option<TenantId>,
600            ) -> Result<TenantResolution, BaseError> {
601                let Some(user) = context.authenticated_user() else {
602                    return Ok(TenantContext::new(TenantId::new(1)).into());
603                };
604                let tenant = requested.unwrap_or_else(|| TenantId::new(10));
605                if user.id == 7 && tenant == TenantId::new(10) {
606                    Ok(TenantContext::new(tenant).into())
607                } else {
608                    Err(BaseError::PermissionDenied(format!(
609                        "用户无权访问租户 {}",
610                        tenant.get()
611                    )))
612                }
613            }
614        }
615
616        /// 构造三方组合应用:公开 Action + 可选认证 + 租户中间件。
617        fn public_chain_app() -> crate::definition::BuiltApp {
618            let module = ModuleSpec::new(
619                ModuleName::new("org.tenant_public").expect("测试 Module 名称应有效"),
620            )
621            .middleware(
622                TokenAuthMiddleware::new(|claims| User::new(7, claims.sub.clone()))
623                    .authenticate_public_actions(),
624            )
625            .middleware(TenantResolverMiddleware::new(GuestOrMemberResolver))
626            .action(
627                ActionSpec::new(
628                    ActionName::new("tenant_auth_probe").expect("测试 Action 名称应有效"),
629                    RouteSpec::new(
630                        HttpMethod::Get,
631                        "/api/v1/org/tenant-public/probe",
632                        "org.tenant_public.tenant_auth_probe",
633                    ),
634                )
635                .public(true),
636                TenantAuthProbe,
637            );
638            AppBuilder::new()
639                .addon(
640                    AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
641                        .module(module),
642                )
643                .build(chain_tools())
644                .expect("三方组合测试应用应构建成功")
645        }
646
647        fn probe_observation(response: ApiResponse) -> (i64, bool) {
648            let data = response.data.expect("探针应返回 JSON data");
649            (
650                data.get("tenant_id")
651                    .and_then(serde_json::Value::as_i64)
652                    .expect("探针应返回 tenant_id"),
653                data.get("authenticated")
654                    .and_then(serde_json::Value::as_bool)
655                    .expect("探针应返回 authenticated 布尔值"),
656            )
657        }
658
659        /// 三方组合:匿名可通行并由租户中间件注入访客上下文;认证信息缺失或
660        /// 无效时一律 fail-closed,绝不降级为匿名。
661        #[tokio::test]
662        async fn public_action_with_optional_auth_and_tenant_middleware_compose() {
663            let app = public_chain_app();
664            let handle = chain_handle(&app, "org.tenant_public", "tenant_auth_probe");
665
666            // 完全匿名(Authorization 头整个缺失):可选认证放行,租户中间件
667            // 注入 resolver 显式选择的访客默认租户,公开 Action 正常执行。
668            let anonymous = app
669                .dispatch(
670                    handle,
671                    Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "10"),
672                )
673                .await
674                .expect("匿名请求应经可选认证放行并获得访客租户上下文");
675            assert_eq!(probe_observation(anonymous), (1, false));
676
677            // 非 Bearer 的 Authorization 头:不降级为匿名。
678            let wrong_scheme = app
679                .dispatch(
680                    handle,
681                    Request::new(serde_json::json!({}))
682                        .header("Authorization", "Basic credentials"),
683                )
684                .await;
685            assert!(matches!(
686                wrong_scheme,
687                Err(BaseError::Unauthorized(message)) if message.contains("Authorization Bearer Token")
688            ));
689
690            // 无效 Bearer Token:不降级为匿名,租户 resolver 不会执行。
691            let invalid = app
692                .dispatch(
693                    handle,
694                    Request::new(serde_json::json!({}))
695                        .header("Authorization", "Bearer invalid-token"),
696                )
697                .await;
698            assert!(matches!(invalid, Err(BaseError::TokenVerifyFailed(_))));
699
700            // 有效 Token 但无撤销存储:同样 fail-closed,不降级为匿名。
701            let token = chain_access_token(&app);
702            let no_store = app
703                .dispatch(
704                    handle,
705                    Request::new(serde_json::json!({}))
706                        .header("Authorization", format!("Bearer {token}")),
707                )
708                .await;
709            assert!(
710                matches!(no_store, Err(BaseError::RedisNotInitialized)),
711                "无撤销存储时不得降级为匿名: {no_store:?}"
712            );
713        }
714    }
715}