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(
416                        crate::token::TokenManager::new_symmetric(
417                            "tenant-chain-test-secretxxxxxxxx",
418                            jsonwebtoken::Algorithm::HS256,
419                            "test-issuer".to_string(),
420                            "test-audience".to_string(),
421                            3600,
422                            7200,
423                        )
424                        .expect("测试 TokenManager 应构建成功"),
425                    )
426                    .build()
427                    .expect("测试 Tools 应构建成功"),
428            )
429        }
430
431        fn chain_handle(
432            app: &crate::definition::BuiltApp,
433            module: &str,
434            action: &str,
435        ) -> crate::definition::ActionHandle {
436            app.registry()
437                .resolve(&ActionRef::new(
438                    ModuleName::new(module).expect("测试 Module 名称应有效"),
439                    ActionName::new(action).expect("测试 Action 名称应有效"),
440                ))
441                .expect("探针 Action 应已注册")
442        }
443
444        fn chain_access_token(app: &crate::definition::BuiltApp) -> String {
445            app.tools()
446                .token()
447                .expect("测试应用应配置 TokenManager")
448                .generate_access_token("user-7", serde_json::json!({}))
449                .expect("测试 Access Token 应生成成功")
450        }
451
452        /// 构造「认证 → 租户」链路应用:受保护的租户探针。
453        fn protected_chain_app() -> crate::definition::BuiltApp {
454            let module = ModuleSpec::new(
455                ModuleName::new("org.tenant_chain").expect("测试 Module 名称应有效"),
456            )
457            .middleware(TokenAuthMiddleware::new(|claims| {
458                User::new(7, claims.sub.clone())
459            }))
460            .middleware(TenantResolverMiddleware::new(MembershipResolver))
461            .action(
462                ActionSpec::new(
463                    ActionName::new("tenant_probe").expect("测试 Action 名称应有效"),
464                    RouteSpec::new(
465                        HttpMethod::Get,
466                        "/api/v1/org/tenant-chain/probe",
467                        "org.tenant_chain.tenant_probe",
468                    ),
469                ),
470                TenantProbe,
471            );
472            AppBuilder::new()
473                .addon(
474                    AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
475                        .module(module),
476                )
477                .build(chain_tools())
478                .expect("链路测试应用应构建成功")
479        }
480
481        #[test]
482        fn build_rejects_tenant_before_token_authentication() {
483            let module = ModuleSpec::new(
484                ModuleName::new("org.tenant_bad_order").expect("测试 Module 名称应有效"),
485            )
486            .middleware(TenantResolverMiddleware::new(MembershipResolver))
487            .middleware(TokenAuthMiddleware::new(|claims| {
488                User::new(7, claims.sub.clone())
489            }))
490            .action(
491                ActionSpec::new(
492                    ActionName::new("tenant_probe").expect("测试 Action 名称应有效"),
493                    RouteSpec::new(
494                        HttpMethod::Get,
495                        "/api/v1/org/tenant-bad-order/probe",
496                        "org.tenant_bad_order.tenant_probe",
497                    ),
498                ),
499                TenantProbe,
500            );
501            let error = AppBuilder::new()
502                .addon(
503                    AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
504                        .module(module),
505                )
506                .build(chain_tools())
507                .expect_err("租户解析先于认证必须在构建期失败");
508            assert!(matches!(
509                error,
510                crate::definition::BuildError::InvalidReference {
511                    kind: "Middleware order",
512                    ..
513                }
514            ));
515        }
516
517        /// 真实链路端到端:认证中间件先于租户中间件执行,任一环节失败即短路。
518        #[tokio::test]
519        async fn token_auth_runs_before_tenant_resolver_and_fails_closed() {
520            let app = protected_chain_app();
521            let handle = chain_handle(&app, "org.tenant_chain", "tenant_probe");
522
523            // 无 Authorization 头:认证中间件短路。若顺序相反(租户先执行),
524            // 报错会是 resolver 的「租户解析需要已认证用户」而非缺少 Token。
525            let missing = app
526                .dispatch(
527                    handle,
528                    Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "10"),
529                )
530                .await;
531            assert!(matches!(
532                missing,
533                Err(BaseError::Unauthorized(message)) if message.contains("Authorization Bearer Token")
534            ));
535
536            // 无效 Token:签名校验失败即短路,请求不会到达租户 resolver。
537            let invalid = app
538                .dispatch(
539                    handle,
540                    Request::new(serde_json::json!({}))
541                        .header("Authorization", "Bearer invalid-token")
542                        .header(TENANT_ID_HEADER, "10"),
543                )
544                .await;
545            assert!(matches!(invalid, Err(BaseError::TokenVerifyFailed(_))));
546
547            // 签名有效但未配置撤销存储:verify_token_checked 不降级跳过撤销检查,
548            // 以 RedisNotInitialized fail-closed,请求仍不会到达租户 resolver。
549            let token = chain_access_token(&app);
550            let no_store = app
551                .dispatch(
552                    handle,
553                    Request::new(serde_json::json!({}))
554                        .header("Authorization", format!("Bearer {token}"))
555                        .header(TENANT_ID_HEADER, "10"),
556                )
557                .await;
558            assert!(
559                matches!(no_store, Err(BaseError::RedisNotInitialized)),
560                "无撤销存储时不得降级放行: {no_store:?}"
561            );
562        }
563
564        /// 同时观察租户上下文与认证状态的公开探针。
565        #[derive(Debug, Serialize, JsonSchema)]
566        struct TenantAuthProbeOutput {
567            tenant_id: i64,
568            authenticated: bool,
569        }
570
571        #[derive(Action)]
572        #[action(name = "tenant_auth_probe", display_name = "租户认证探针", public)]
573        struct TenantAuthProbe;
574
575        #[async_trait]
576        impl TypedHandler for TenantAuthProbe {
577            type Input = EmptyInput;
578            type Output = TenantAuthProbeOutput;
579
580            async fn handle(
581                &self,
582                context: ActionContext,
583                _input: Self::Input,
584            ) -> Result<Self::Output, BaseError> {
585                let tenant = context.tenant()?;
586                Ok(TenantAuthProbeOutput {
587                    tenant_id: tenant.id().get(),
588                    authenticated: context.authenticated_user().is_some(),
589                })
590            }
591        }
592
593        /// 显式允许匿名的 resolver:匿名请求忽略客户端候选,落入服务端选择的
594        /// 访客默认租户;已认证成员沿用 MembershipResolver 的候选校验规则。
595        struct GuestOrMemberResolver;
596
597        #[async_trait]
598        impl TenantResolver for GuestOrMemberResolver {
599            async fn resolve(
600                &self,
601                context: &ActionContext,
602                requested: Option<TenantId>,
603            ) -> Result<TenantResolution, BaseError> {
604                let Some(user) = context.authenticated_user() else {
605                    return Ok(TenantContext::new(TenantId::new(1)).into());
606                };
607                let tenant = requested.unwrap_or_else(|| TenantId::new(10));
608                if user.id == 7 && tenant == TenantId::new(10) {
609                    Ok(TenantContext::new(tenant).into())
610                } else {
611                    Err(BaseError::PermissionDenied(format!(
612                        "用户无权访问租户 {}",
613                        tenant.get()
614                    )))
615                }
616            }
617        }
618
619        /// 构造三方组合应用:公开 Action + 可选认证 + 租户中间件。
620        fn public_chain_app() -> crate::definition::BuiltApp {
621            let module = ModuleSpec::new(
622                ModuleName::new("org.tenant_public").expect("测试 Module 名称应有效"),
623            )
624            .middleware(
625                TokenAuthMiddleware::new(|claims| User::new(7, claims.sub.clone()))
626                    .authenticate_public_actions(),
627            )
628            .middleware(TenantResolverMiddleware::new(GuestOrMemberResolver))
629            .action(
630                ActionSpec::new(
631                    ActionName::new("tenant_auth_probe").expect("测试 Action 名称应有效"),
632                    RouteSpec::new(
633                        HttpMethod::Get,
634                        "/api/v1/org/tenant-public/probe",
635                        "org.tenant_public.tenant_auth_probe",
636                    ),
637                )
638                .public(true),
639                TenantAuthProbe,
640            );
641            AppBuilder::new()
642                .addon(
643                    AddonSpec::new(AddonName::new("org").expect("测试 Addon 名称应有效"))
644                        .module(module),
645                )
646                .build(chain_tools())
647                .expect("三方组合测试应用应构建成功")
648        }
649
650        fn probe_observation(response: ApiResponse) -> (i64, bool) {
651            let data = response.data.expect("探针应返回 JSON data");
652            (
653                data.get("tenant_id")
654                    .and_then(serde_json::Value::as_i64)
655                    .expect("探针应返回 tenant_id"),
656                data.get("authenticated")
657                    .and_then(serde_json::Value::as_bool)
658                    .expect("探针应返回 authenticated 布尔值"),
659            )
660        }
661
662        /// 三方组合:匿名可通行并由租户中间件注入访客上下文;认证信息缺失或
663        /// 无效时一律 fail-closed,绝不降级为匿名。
664        #[tokio::test]
665        async fn public_action_with_optional_auth_and_tenant_middleware_compose() {
666            let app = public_chain_app();
667            let handle = chain_handle(&app, "org.tenant_public", "tenant_auth_probe");
668
669            // 完全匿名(Authorization 头整个缺失):可选认证放行,租户中间件
670            // 注入 resolver 显式选择的访客默认租户,公开 Action 正常执行。
671            let anonymous = app
672                .dispatch(
673                    handle,
674                    Request::new(serde_json::json!({})).header(TENANT_ID_HEADER, "10"),
675                )
676                .await
677                .expect("匿名请求应经可选认证放行并获得访客租户上下文");
678            assert_eq!(probe_observation(anonymous), (1, false));
679
680            // 非 Bearer 的 Authorization 头:不降级为匿名。
681            let wrong_scheme = app
682                .dispatch(
683                    handle,
684                    Request::new(serde_json::json!({}))
685                        .header("Authorization", "Basic credentials"),
686                )
687                .await;
688            assert!(matches!(
689                wrong_scheme,
690                Err(BaseError::Unauthorized(message)) if message.contains("Authorization Bearer Token")
691            ));
692
693            // 无效 Bearer Token:不降级为匿名,租户 resolver 不会执行。
694            let invalid = app
695                .dispatch(
696                    handle,
697                    Request::new(serde_json::json!({}))
698                        .header("Authorization", "Bearer invalid-token"),
699                )
700                .await;
701            assert!(matches!(invalid, Err(BaseError::TokenVerifyFailed(_))));
702
703            // 有效 Token 但无撤销存储:同样 fail-closed,不降级为匿名。
704            let token = chain_access_token(&app);
705            let no_store = app
706                .dispatch(
707                    handle,
708                    Request::new(serde_json::json!({}))
709                        .header("Authorization", format!("Bearer {token}")),
710                )
711                .await;
712            assert!(
713                matches!(no_store, Err(BaseError::RedisNotInitialized)),
714                "无撤销存储时不得降级为匿名: {no_store:?}"
715            );
716        }
717    }
718}