use crate::error::{GarrisonError, GarrisonResult};
use crate::loc;
use crate::protocol::social::urlencoding;
use crate::protocol::social::{provider_names, SocialLoginProvider, SocialUserInfo};
use async_trait::async_trait;
use serde_json::Value;
fn sanitize_http_error(e: &reqwest::Error) -> String {
if e.is_connect() {
"connection error".to_string()
} else if e.is_timeout() {
"request timeout".to_string()
} else if e.is_request() {
"request error".to_string()
} else {
"network error".to_string()
}
}
fn strip_sensitive_fields(mut raw: Value) -> Value {
const SENSITIVE_FIELDS: [&str; 2] = ["session_key", "access_token"];
if let Some(obj) = raw.as_object_mut() {
for field in SENSITIVE_FIELDS {
obj.remove(field);
}
}
raw
}
fn validate_redirect_uri(redirect_uri: &str) -> GarrisonResult<()> {
if !redirect_uri.starts_with("https://") {
return Err(GarrisonError::InvalidParam(loc!(
"wechat-redirect-uri-must-be-https",
"wechat redirect_uri must be an https url".to_string()
)));
}
Ok(())
}
const WECHAT_AUTH_URL: &str = "https://open.weixin.qq.com/connect/qrconnect";
const WECHAT_TOKEN_URL: &str = "https://api.weixin.qq.com/sns/oauth2/access_token";
const WECHAT_USERINFO_URL: &str = "https://api.weixin.qq.com/sns/userinfo";
pub struct WechatProvider {
client_id: String,
client_secret: String,
http: reqwest::Client,
token_url: String,
userinfo_url: String,
}
impl WechatProvider {
pub fn new(client_id: &str, client_secret: &str) -> Self {
Self {
client_id: client_id.to_string(),
client_secret: client_secret.to_string(),
http: reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(30))
.connect_timeout(std::time::Duration::from_secs(10))
.build()
.expect("reqwest client build with timeout should succeed"),
token_url: WECHAT_TOKEN_URL.to_string(),
userinfo_url: WECHAT_USERINFO_URL.to_string(),
}
}
#[must_use]
pub fn with_token_url(mut self, token_url: impl Into<String>) -> Self {
self.token_url = token_url.into();
self
}
#[must_use]
pub fn with_userinfo_url(mut self, userinfo_url: impl Into<String>) -> Self {
self.userinfo_url = userinfo_url.into();
self
}
}
#[async_trait]
impl SocialLoginProvider for WechatProvider {
async fn get_authorization_url(
&self,
state: &str,
redirect_uri: &str,
) -> GarrisonResult<String> {
validate_redirect_uri(redirect_uri)?;
Ok(format!(
"{}?appid={}&redirect_uri={}&response_type=code&scope=snsapi_login&state={}#wechat_redirect",
WECHAT_AUTH_URL,
urlencoding::encode(&self.client_id),
urlencoding::encode(redirect_uri),
urlencoding::encode(state),
))
}
async fn exchange_token(&self, code: &str, _state: &str) -> GarrisonResult<SocialUserInfo> {
let url = format!(
"{}?appid={}&secret={}&code={}&grant_type=authorization_code",
self.token_url,
urlencoding::encode(&self.client_id),
urlencoding::encode(&self.client_secret),
urlencoding::encode(code),
);
let resp = self.http.get(&url).send().await.map_err(|e| {
let detail = sanitize_http_error(&e);
GarrisonError::Network(loc!(
"wechat-token-request-failed",
format!("wechat token request failed: {}", detail),
("detail", &detail)
))
})?;
if !resp.status().is_success() {
return Err(GarrisonError::Network(loc!(
"wechat-token-request-failed",
format!("wechat token request failed: {}", resp.status()),
("detail", &resp.status().to_string())
)));
}
let raw: Value = resp.json().await.map_err(|e| {
let detail = sanitize_http_error(&e);
GarrisonError::Network(loc!(
"wechat-token-response-parse-failed",
format!("wechat token response parse failed: {}", detail),
("detail", &detail)
))
})?;
if let Some(errcode) = raw.get("errcode").and_then(|v| v.as_i64()) {
if errcode != 0 {
let errmsg = raw
.get("errmsg")
.and_then(|v| v.as_str())
.unwrap_or("unknown wechat error");
return Err(GarrisonError::Network(loc!(
"wechat-error-response",
format!("wechat error {}: {}", errcode, errmsg),
("code", &errcode.to_string()),
("message", errmsg)
)));
}
}
let provider_user_id = raw
.get("openid")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.ok_or_else(|| {
GarrisonError::Network(loc!(
"wechat-response-missing-openid",
"wechat response missing openid field".to_string()
))
})?
.to_string();
let union_id = raw
.get("unionid")
.and_then(|v| v.as_str())
.map(String::from);
Ok(SocialUserInfo {
provider: provider_names::WECHAT.to_string(),
provider_user_id,
nickname: None,
avatar: None,
union_id,
raw: strip_sensitive_fields(raw),
})
}
async fn get_user_info(&self, access_token: &str) -> GarrisonResult<SocialUserInfo> {
let (access_token_value, openid) = match access_token.split_once('|') {
Some((tok, oid)) => (tok, oid),
None => (access_token, ""),
};
let url = format!(
"{}?access_token={}&openid={}",
self.userinfo_url,
urlencoding::encode(access_token_value),
urlencoding::encode(openid),
);
let resp = self.http.get(&url).send().await.map_err(|e| {
let detail = sanitize_http_error(&e);
GarrisonError::Network(loc!(
"wechat-userinfo-request-failed",
format!("wechat userinfo request failed: {}", detail),
("detail", &detail)
))
})?;
if !resp.status().is_success() {
return Err(GarrisonError::Network(loc!(
"wechat-userinfo-request-failed",
format!("wechat userinfo request failed: {}", resp.status()),
("detail", &resp.status().to_string())
)));
}
let raw: Value = resp.json().await.map_err(|e| {
let detail = sanitize_http_error(&e);
GarrisonError::Network(loc!(
"wechat-userinfo-response-parse-failed",
format!("wechat userinfo response parse failed: {}", detail),
("detail", &detail)
))
})?;
if let Some(errcode) = raw.get("errcode").and_then(|v| v.as_i64()) {
if errcode != 0 {
let errmsg = raw
.get("errmsg")
.and_then(|v| v.as_str())
.unwrap_or("unknown wechat error");
return Err(GarrisonError::Network(loc!(
"wechat-error-response",
format!("wechat error {}: {}", errcode, errmsg),
("code", &errcode.to_string()),
("message", errmsg)
)));
}
}
let provider_user_id = raw
.get("openid")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.ok_or_else(|| {
GarrisonError::Network(loc!(
"wechat-userinfo-response-missing-openid",
"wechat userinfo response missing openid field".to_string()
))
})?
.to_string();
let nickname = raw
.get("nickname")
.and_then(|v| v.as_str())
.map(String::from);
let avatar = raw
.get("headimgurl")
.and_then(|v| v.as_str())
.map(String::from);
let union_id = raw
.get("unionid")
.and_then(|v| v.as_str())
.map(String::from);
Ok(SocialUserInfo {
provider: provider_names::WECHAT.to_string(),
provider_user_id,
nickname,
avatar,
union_id,
raw: strip_sensitive_fields(raw),
})
}
}
#[cfg(feature = "protocol-zeroize")]
impl Drop for WechatProvider {
fn drop(&mut self) {
use zeroize::Zeroize;
self.client_secret.zeroize();
}
}
const WECHAT_MINI_APP_JSCODE2SESSION_URL: &str = "https://api.weixin.qq.com/sns/jscode2session";
pub struct WechatMiniAppProvider {
client_id: String,
client_secret: String,
http: reqwest::Client,
jscode2session_url: String,
}
impl WechatMiniAppProvider {
pub fn new(client_id: &str, client_secret: &str) -> Self {
Self {
client_id: client_id.to_string(),
client_secret: client_secret.to_string(),
http: reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(30))
.connect_timeout(std::time::Duration::from_secs(10))
.build()
.expect("reqwest client build with timeout should succeed"),
jscode2session_url: WECHAT_MINI_APP_JSCODE2SESSION_URL.to_string(),
}
}
#[must_use]
pub fn with_jscode2session_url(mut self, url: impl Into<String>) -> Self {
self.jscode2session_url = url.into();
self
}
}
#[async_trait]
impl SocialLoginProvider for WechatMiniAppProvider {
async fn get_authorization_url(
&self,
_state: &str,
_redirect_uri: &str,
) -> GarrisonResult<String> {
Err(GarrisonError::NotImplemented(
"wechat-mini-app-get-authorization-url-not-supported::".to_string(),
))
}
async fn exchange_token(&self, code: &str, _state: &str) -> GarrisonResult<SocialUserInfo> {
self.get_user_info(code).await
}
async fn get_user_info(&self, access_token: &str) -> GarrisonResult<SocialUserInfo> {
let js_code = access_token;
let url = format!(
"{}?appid={}&secret={}&js_code={}&grant_type=authorization_code",
self.jscode2session_url,
urlencoding::encode(&self.client_id),
urlencoding::encode(&self.client_secret),
urlencoding::encode(js_code),
);
let resp = self.http.get(&url).send().await.map_err(|e| {
let detail = sanitize_http_error(&e);
GarrisonError::Network(loc!(
"wechat-mini-app-jscode2session-request-failed",
format!("wechat mini-app jscode2session request failed: {}", detail),
("detail", &detail)
))
})?;
if !resp.status().is_success() {
return Err(GarrisonError::Network(loc!(
"wechat-mini-app-jscode2session-request-failed",
format!(
"wechat mini-app jscode2session request failed: {}",
resp.status()
),
("detail", &resp.status().to_string())
)));
}
let raw: Value = resp.json().await.map_err(|e| {
let detail = sanitize_http_error(&e);
GarrisonError::Network(loc!(
"wechat-mini-app-jscode2session-response-parse-failed",
format!(
"wechat mini-app jscode2session response parse failed: {}",
detail
),
("detail", &detail)
))
})?;
if let Some(errcode) = raw.get("errcode").and_then(|v| v.as_i64()) {
if errcode != 0 {
let errmsg = raw
.get("errmsg")
.and_then(|v| v.as_str())
.unwrap_or("unknown wechat error");
return Err(GarrisonError::Network(loc!(
"wechat-mini-app-error-response",
format!("wechat mini-app error {}: {}", errcode, errmsg),
("code", &errcode.to_string()),
("message", errmsg)
)));
}
}
let provider_user_id = raw
.get("openid")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.ok_or_else(|| {
GarrisonError::Network(loc!(
"wechat-mini-app-jscode2session-response-missing-openid",
"wechat mini-app jscode2session response missing openid field".to_string()
))
})?
.to_string();
let union_id = raw
.get("unionid")
.and_then(|v| v.as_str())
.map(String::from);
Ok(SocialUserInfo {
provider: provider_names::WECHAT_MINI_APP.to_string(),
provider_user_id,
nickname: None,
avatar: None,
union_id,
raw: strip_sensitive_fields(raw),
})
}
}
#[cfg(feature = "protocol-zeroize")]
impl Drop for WechatMiniAppProvider {
fn drop(&mut self) {
use zeroize::Zeroize;
self.client_secret.zeroize();
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn wechat_provider_get_authorization_url_returns_correct_format() {
let provider = WechatProvider::new("wx_appid", "wx_secret");
let url = provider
.get_authorization_url("state123", "https://example.com/cb")
.await
.expect("get_authorization_url 应返回 Ok");
assert!(
url.starts_with("https://open.weixin.qq.com/connect/qrconnect?"),
"URL 应以微信扫码登录端点开头,实际: {}",
url
);
assert!(
url.contains("appid=wx_appid"),
"URL 应含 appid 参数,实际: {}",
url
);
assert!(
url.contains("response_type=code"),
"URL 应含 response_type=code 参数(OAuth2 authorization_code 模式),实际: {}",
url
);
assert!(
url.contains("scope=snsapi_login"),
"URL 应含 scope=snsapi_login 参数(网站应用扫码登录专用 scope),实际: {}",
url
);
assert!(
url.contains("state=state123"),
"URL 应含 state 参数,实际: {}",
url
);
assert!(
url.ends_with("#wechat_redirect"),
"URL 应以 #wechat_redirect 锚点结尾(微信强匹配校验),实际: {}",
url
);
}
#[tokio::test]
async fn wechat_provider_exchange_token_parses_access_token_from_response() {
use wiremock::matchers::{method, path, query_param};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/oauth2/access_token"))
.and(query_param("appid", "wx_appid"))
.and(query_param("secret", "wx_secret"))
.and(query_param("code", "code"))
.and(query_param("grant_type", "authorization_code"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"access_token": "tok123",
"openid": "openid456",
"unionid": "union789",
})))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_token_url(format!("{}/sns/oauth2/access_token", server.uri()));
let user_info = provider
.exchange_token("code", "state")
.await
.expect("exchange_token 应返回 Ok");
assert_eq!(user_info.provider_user_id, "openid456");
assert_eq!(user_info.union_id.as_deref(), Some("union789"));
}
#[tokio::test]
async fn wechat_provider_get_user_info_parses_nickname_and_avatar() {
use wiremock::matchers::{method, path, query_param};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/userinfo"))
.and(query_param("access_token", "tok123"))
.and(query_param("openid", "openid1"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"openid": "openid1",
"nickname": "Alice",
"headimgurl": "https://img.example.com/a.png",
"unionid": "union1",
})))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_userinfo_url(format!("{}/sns/userinfo", server.uri()));
let user_info = provider
.get_user_info("tok123|openid1")
.await
.expect("get_user_info 应返回 Ok");
assert_eq!(user_info.provider, provider_names::WECHAT);
assert_eq!(user_info.provider_user_id, "openid1");
assert_eq!(user_info.nickname.as_deref(), Some("Alice"));
assert_eq!(
user_info.avatar.as_deref(),
Some("https://img.example.com/a.png")
);
assert_eq!(user_info.union_id.as_deref(), Some("union1"));
}
#[tokio::test]
async fn wechat_provider_get_user_info_returns_error_on_http_failure() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/userinfo"))
.respond_with(ResponseTemplate::new(500))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_userinfo_url(format!("{}/sns/userinfo", server.uri()));
let result = provider.get_user_info("tok123|openid1").await;
assert!(
result.is_err(),
"HTTP 500 应返回 Err 而非 panic,实际: {:?}",
result
);
match result {
Err(GarrisonError::Network(_)) => {},
Err(other) => panic!("期望 GarrisonError::Network,实际: {:?}", other),
Ok(_) => unreachable!("HTTP 500 不应返回 Ok"),
}
}
#[tokio::test]
async fn wechat_mini_app_get_user_info_success() {
use wiremock::matchers::{method, path, query_param};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/jscode2session"))
.and(query_param("appid", "wx_appid"))
.and(query_param("secret", "wx_secret"))
.and(query_param("js_code", "js_code_123"))
.and(query_param("grant_type", "authorization_code"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"openid": "openid_mini_1",
"session_key": "sess_key_abc",
"unionid": "union_mini_1",
})))
.mount(&server)
.await;
let provider = WechatMiniAppProvider::new("wx_appid", "wx_secret")
.with_jscode2session_url(format!("{}/sns/jscode2session", server.uri()));
let user_info = provider
.get_user_info("js_code_123")
.await
.expect("get_user_info 应返回 Ok");
assert_eq!(user_info.provider, provider_names::WECHAT_MINI_APP);
assert_eq!(user_info.provider_user_id, "openid_mini_1");
assert_eq!(user_info.union_id.as_deref(), Some("union_mini_1"));
}
#[tokio::test]
async fn wechat_mini_app_get_user_info_invalid_code() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/jscode2session"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"errcode": 40029,
"errmsg": "invalid code",
})))
.mount(&server)
.await;
let provider = WechatMiniAppProvider::new("wx_appid", "wx_secret")
.with_jscode2session_url(format!("{}/sns/jscode2session", server.uri()));
let result = provider.get_user_info("bad_code").await;
assert!(
result.is_err(),
"errcode=40029 应返回 Err 而非 Ok,实际: {:?}",
result
);
}
#[tokio::test]
async fn wechat_mini_app_get_user_info_network_error() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/jscode2session"))
.respond_with(ResponseTemplate::new(500))
.mount(&server)
.await;
let provider = WechatMiniAppProvider::new("wx_appid", "wx_secret")
.with_jscode2session_url(format!("{}/sns/jscode2session", server.uri()));
let result = provider.get_user_info("js_code_123").await;
assert!(
result.is_err(),
"HTTP 500 应返回 Err 而非 Ok,实际: {:?}",
result
);
match result {
Err(GarrisonError::Network(_)) => {},
Err(other) => panic!("期望 GarrisonError::Network,实际: {:?}", other),
Ok(_) => unreachable!("HTTP 500 不应返回 Ok"),
}
}
#[tokio::test]
async fn wechat_mini_app_get_user_info_missing_openid() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/jscode2session"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"session_key": "sess_key_abc",
})))
.mount(&server)
.await;
let provider = WechatMiniAppProvider::new("wx_appid", "wx_secret")
.with_jscode2session_url(format!("{}/sns/jscode2session", server.uri()));
let result = provider.get_user_info("js_code_123").await;
assert!(
result.is_err(),
"缺少 openid 应返回 Err 而非 Ok,实际: {:?}",
result
);
}
#[tokio::test]
async fn wechat_provider_new_sets_client_id() {
let provider = WechatProvider::new("my_appid", "my_secret");
let url = provider
.get_authorization_url("state", "https://example.com/cb")
.await
.expect("get_authorization_url 应返回 Ok");
assert!(
url.contains("appid=my_appid"),
"URL 应含 client_id,实际: {}",
url
);
}
#[tokio::test]
async fn wechat_provider_with_token_url_returns_self_for_chaining() {
let provider = WechatProvider::new("appid", "secret")
.with_token_url("https://custom.token.url")
.with_userinfo_url("https://custom.userinfo.url");
let url = provider
.get_authorization_url("s", "https://example.com/cb")
.await
.expect("get_authorization_url 应返回 Ok");
assert!(url.contains("appid=appid"));
}
#[tokio::test]
async fn wechat_provider_get_authorization_url_encodes_special_chars() {
let provider = WechatProvider::new("appid", "secret");
let url = provider
.get_authorization_url("state with space", "https://example.com/cb?foo=bar")
.await
.expect("get_authorization_url 应返回 Ok");
assert!(!url.contains("state with space"), "state 应被 URL 编码");
assert!(
url.contains("state=state%20with%20space"),
"state 空格应编码为 %20,实际: {}",
url
);
}
#[tokio::test]
async fn wechat_provider_exchange_token_errcode_nonzero_returns_error() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/oauth2/access_token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"errcode": 40029,
"errmsg": "invalid code",
})))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_token_url(format!("{}/sns/oauth2/access_token", server.uri()));
let result = provider.exchange_token("bad_code", "state").await;
assert!(result.is_err(), "errcode!=0 应返回 Err");
match result {
Err(GarrisonError::Network(_)) => {},
Err(other) => panic!("期望 Network 错误,实际: {:?}", other),
Ok(_) => unreachable!("errcode!=0 不应返回 Ok"),
}
}
#[tokio::test]
async fn wechat_provider_exchange_token_missing_openid_returns_error() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/oauth2/access_token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"access_token": "tok123",
"session_key": "sess",
})))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_token_url(format!("{}/sns/oauth2/access_token", server.uri()));
let result = provider.exchange_token("code", "state").await;
assert!(result.is_err(), "缺少 openid 应返回 Err");
match result {
Err(GarrisonError::Network(_)) => {},
Err(other) => panic!("期望 Network 错误,实际: {:?}", other),
Ok(_) => unreachable!("缺少 openid 不应返回 Ok"),
}
}
#[tokio::test]
async fn wechat_provider_exchange_token_http_500_returns_error() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/oauth2/access_token"))
.respond_with(ResponseTemplate::new(500))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_token_url(format!("{}/sns/oauth2/access_token", server.uri()));
let result = provider.exchange_token("code", "state").await;
assert!(result.is_err(), "HTTP 500 应返回 Err");
match result {
Err(GarrisonError::Network(_)) => {},
Err(other) => panic!("期望 Network 错误,实际: {:?}", other),
Ok(_) => unreachable!("HTTP 500 不应返回 Ok"),
}
}
#[tokio::test]
async fn wechat_provider_exchange_token_without_unionid_returns_none() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/oauth2/access_token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"access_token": "tok123",
"openid": "openid456",
})))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_token_url(format!("{}/sns/oauth2/access_token", server.uri()));
let user_info = provider
.exchange_token("code", "state")
.await
.expect("exchange_token 应返回 Ok");
assert_eq!(user_info.provider_user_id, "openid456");
assert!(user_info.union_id.is_none(), "无 unionid 时应为 None");
assert!(user_info.nickname.is_none());
assert!(user_info.avatar.is_none());
}
#[tokio::test]
async fn wechat_provider_get_user_info_without_separator_uses_empty_openid() {
use wiremock::matchers::{method, path, query_param};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/userinfo"))
.and(query_param("access_token", "tok_only"))
.and(query_param("openid", ""))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"openid": "openid1",
"nickname": "Test",
})))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_userinfo_url(format!("{}/sns/userinfo", server.uri()));
let user_info = provider
.get_user_info("tok_only")
.await
.expect("get_user_info 应返回 Ok");
assert_eq!(user_info.provider_user_id, "openid1");
assert_eq!(user_info.nickname.as_deref(), Some("Test"));
}
#[tokio::test]
async fn wechat_provider_get_user_info_errcode_nonzero_returns_error() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/userinfo"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"errcode": 48001,
"errmsg": "api unauthorized",
})))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_userinfo_url(format!("{}/sns/userinfo", server.uri()));
let result = provider.get_user_info("tok|openid").await;
assert!(result.is_err(), "errcode!=0 应返回 Err");
match result {
Err(GarrisonError::Network(_)) => {},
Err(other) => panic!("期望 Network 错误,实际: {:?}", other),
Ok(_) => unreachable!("errcode!=0 不应返回 Ok"),
}
}
#[tokio::test]
async fn wechat_provider_get_user_info_missing_openid_returns_error() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/userinfo"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"nickname": "NoOpenid",
"headimgurl": "https://img.example.com/a.png",
})))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_userinfo_url(format!("{}/sns/userinfo", server.uri()));
let result = provider.get_user_info("tok|openid").await;
assert!(result.is_err(), "缺少 openid 应返回 Err");
match result {
Err(GarrisonError::Network(_)) => {},
Err(other) => panic!("期望 Network 错误,实际: {:?}", other),
Ok(_) => unreachable!("缺少 openid 不应返回 Ok"),
}
}
#[tokio::test]
async fn wechat_provider_get_user_info_missing_optional_fields_returns_none() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/userinfo"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"openid": "openid_only",
})))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_userinfo_url(format!("{}/sns/userinfo", server.uri()));
let user_info = provider
.get_user_info("tok|openid")
.await
.expect("get_user_info 应返回 Ok");
assert_eq!(user_info.provider_user_id, "openid_only");
assert!(user_info.nickname.is_none());
assert!(user_info.avatar.is_none());
assert!(user_info.union_id.is_none());
}
#[tokio::test]
async fn wechat_mini_app_provider_new_constructs() {
let provider = WechatMiniAppProvider::new("mini_appid", "mini_secret");
let result = provider.get_authorization_url("state", "redirect").await;
assert!(
result.is_err(),
"get_authorization_url 应返回 NotImplemented"
);
}
#[tokio::test]
async fn wechat_mini_app_provider_with_jscode2session_url_chaining() {
let provider = WechatMiniAppProvider::new("appid", "secret")
.with_jscode2session_url("https://custom.jscode2session.url");
let result = provider.get_authorization_url("s", "r").await;
assert!(result.is_err());
}
#[tokio::test]
async fn wechat_mini_app_provider_get_authorization_url_returns_not_implemented() {
let provider = WechatMiniAppProvider::new("appid", "secret");
let result = provider.get_authorization_url("state", "redirect").await;
match result {
Err(GarrisonError::NotImplemented(_)) => {},
Err(other) => panic!("期望 NotImplemented,实际: {:?}", other),
Ok(_) => unreachable!("不应返回 Ok"),
}
}
#[tokio::test]
async fn wechat_mini_app_provider_exchange_token_delegates_to_get_user_info() {
use wiremock::matchers::{method, path, query_param};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/jscode2session"))
.and(query_param("js_code", "js_code_xyz"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"openid": "openid_via_exchange",
"session_key": "sess_key",
})))
.mount(&server)
.await;
let provider = WechatMiniAppProvider::new("appid", "secret")
.with_jscode2session_url(format!("{}/sns/jscode2session", server.uri()));
let user_info = provider
.exchange_token("js_code_xyz", "state")
.await
.expect("exchange_token 应返回 Ok");
assert_eq!(user_info.provider_user_id, "openid_via_exchange");
assert_eq!(user_info.provider, provider_names::WECHAT_MINI_APP);
}
#[tokio::test]
async fn wechat_mini_app_provider_get_user_info_response_parse_failure() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/jscode2session"))
.respond_with(ResponseTemplate::new(200).set_body_json("invalid_json_string"))
.mount(&server)
.await;
let provider = WechatMiniAppProvider::new("appid", "secret")
.with_jscode2session_url(format!("{}/sns/jscode2session", server.uri()));
let result = provider.get_user_info("js_code").await;
assert!(result.is_err(), "JSON 解析失败应返回 Err");
}
#[tokio::test]
async fn wechat_mini_app_provider_get_user_info_without_unionid() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/jscode2session"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"openid": "openid_no_union",
"session_key": "sess_key",
})))
.mount(&server)
.await;
let provider = WechatMiniAppProvider::new("appid", "secret")
.with_jscode2session_url(format!("{}/sns/jscode2session", server.uri()));
let user_info = provider
.get_user_info("js_code")
.await
.expect("get_user_info 应返回 Ok");
assert_eq!(user_info.provider_user_id, "openid_no_union");
assert!(user_info.union_id.is_none());
assert!(user_info.nickname.is_none());
assert!(user_info.avatar.is_none());
}
#[tokio::test]
async fn wechat_mini_app_provider_get_user_info_errcode_zero_succeeds() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/jscode2session"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"errcode": 0,
"openid": "openid_ok",
"session_key": "sess",
})))
.mount(&server)
.await;
let provider = WechatMiniAppProvider::new("appid", "secret")
.with_jscode2session_url(format!("{}/sns/jscode2session", server.uri()));
let user_info = provider
.get_user_info("js_code")
.await
.expect("errcode=0 应返回 Ok");
assert_eq!(user_info.provider_user_id, "openid_ok");
}
#[tokio::test]
async fn wechat_provider_exchange_token_errcode_zero_succeeds() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/oauth2/access_token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"errcode": 0,
"access_token": "tok123",
"openid": "openid456",
})))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_token_url(format!("{}/sns/oauth2/access_token", server.uri()));
let user_info = provider
.exchange_token("code", "state")
.await
.expect("errcode=0 应返回 Ok");
assert_eq!(user_info.provider_user_id, "openid456");
}
#[tokio::test]
async fn wechat_provider_get_user_info_errcode_zero_succeeds() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/userinfo"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"errcode": 0,
"openid": "openid_ok",
"nickname": "Alice",
})))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_userinfo_url(format!("{}/sns/userinfo", server.uri()));
let user_info = provider
.get_user_info("tok|openid")
.await
.expect("errcode=0 应返回 Ok");
assert_eq!(user_info.provider_user_id, "openid_ok");
assert_eq!(user_info.nickname.as_deref(), Some("Alice"));
}
#[tokio::test]
async fn wechat_provider_get_authorization_url_rejects_non_https_redirect_uri() {
let provider = WechatProvider::new("appid", "secret");
for bad in [
"http://example.com/cb",
"ftp://example.com/cb",
"/relative",
"",
] {
let result = provider.get_authorization_url("state", bad).await;
match result {
Err(GarrisonError::InvalidParam(msg)) => assert!(
msg.contains("https"),
"错误消息应说明 redirect_uri 须为 https,实际: {}",
msg
),
Err(other) => panic!(
"非 https redirect_uri 应返回 InvalidParam,实际: {:?}",
other
),
Ok(url) => panic!("非 https redirect_uri 不应拼接授权 URL,实际: {}", url),
}
}
}
#[tokio::test]
async fn wechat_provider_exchange_token_raw_strips_access_token() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/oauth2/access_token"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"access_token": "SECRET_TOKEN",
"openid": "openid456",
"unionid": "union789",
})))
.mount(&server)
.await;
let provider = WechatProvider::new("wx_appid", "wx_secret")
.with_token_url(format!("{}/sns/oauth2/access_token", server.uri()));
let user_info = provider
.exchange_token("code", "state")
.await
.expect("exchange_token 应返回 Ok");
assert!(
user_info.raw.get("access_token").is_none(),
"raw 不应保留 access_token(敏感凭据剥离),实际: {}",
user_info.raw
);
assert_eq!(
user_info.raw.get("openid").and_then(|v| v.as_str()),
Some("openid456")
);
}
#[tokio::test]
async fn wechat_mini_app_get_user_info_raw_strips_session_key() {
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
let server = MockServer::start().await;
Mock::given(method("GET"))
.and(path("/sns/jscode2session"))
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
"openid": "openid_mini_1",
"session_key": "SECRET_SESSION_KEY",
"unionid": "union_mini_1",
})))
.mount(&server)
.await;
let provider = WechatMiniAppProvider::new("appid", "secret")
.with_jscode2session_url(format!("{}/sns/jscode2session", server.uri()));
let user_info = provider
.get_user_info("js_code")
.await
.expect("get_user_info 应返回 Ok");
assert!(
user_info.raw.get("session_key").is_none(),
"raw 不应保留 session_key(解密凭据剥离),实际: {}",
user_info.raw
);
assert_eq!(user_info.provider_user_id, "openid_mini_1");
}
}