use crate::application::dto::webhook_request::{
CreateWebhookRequest, WebhookListEntry, WebhookListResponse, WebhookResponse,
};
use crate::config::settings::Settings;
use crate::domain::repositories::webhook_repository::WebhookRepository;
use crate::domain::services::rate_limiting_service::RateLimitingService;
use crate::domain::services::webhook_service::{
verify_webhook_signature_from_parts, WEBHOOK_AUTH_FAILED,
};
use crate::domain::use_cases::create_webhook::CreateWebhookUseCase;
use crate::infrastructure::security::ssrf::validate_url;
use crate::presentation::errors::CrawlRsError;
use crate::presentation::handlers::response_builder::{success_response, ApiResponse};
use crate::presentation::helpers::rate_limit_helper::check_rate_limit_as_app_error;
use crate::presentation::middleware::auth_middleware::AuthState;
use axum::body::Bytes;
use axum::http::{HeaderMap, StatusCode};
use axum::{Extension, Json};
use std::sync::Arc;
const SIGNATURE_HEADER: &str = standardwebhooks::HEADER_WEBHOOK_SIGNATURE;
const TIMESTAMP_HEADER: &str = standardwebhooks::HEADER_WEBHOOK_TIMESTAMP;
const MSG_ID_HEADER: &str = standardwebhooks::HEADER_WEBHOOK_ID;
fn auth_error() -> CrawlRsError {
CrawlRsError::Authentication(WEBHOOK_AUTH_FAILED.to_string())
}
fn verify_webhook_signature_from_headers(
headers: &HeaderMap,
secret: &str,
body: &[u8],
) -> Result<(), CrawlRsError> {
let signature = headers
.get(SIGNATURE_HEADER)
.and_then(|h| h.to_str().ok())
.ok_or_else(auth_error)?;
let timestamp_str = headers
.get(TIMESTAMP_HEADER)
.and_then(|h| h.to_str().ok())
.ok_or_else(auth_error)?;
let msg_id = headers
.get(MSG_ID_HEADER)
.and_then(|h| h.to_str().ok())
.unwrap_or("none");
verify_webhook_signature_from_parts(secret, signature, timestamp_str, msg_id, body)
.map_err(|_| auth_error())
}
pub async fn create_webhook<R: WebhookRepository>(
Extension(repo): Extension<Arc<R>>,
Extension(rate_limiting_service): Extension<Arc<dyn RateLimitingService>>,
Extension(auth_state): Extension<AuthState>,
Extension(settings): Extension<Arc<Settings>>,
headers: HeaderMap,
body: Bytes,
) -> Result<axum::response::Response, CrawlRsError> {
check_rate_limit_as_app_error(
rate_limiting_service.as_ref(),
auth_state.api_key_id,
"/v1/webhooks",
)
.await?;
verify_webhook_signature_from_headers(&headers, settings.webhook.secret(), &body).inspect_err(
|_| {
log::warn!(
"Webhook signature verification failed team_id={} api_key_id={}",
auth_state.team_id,
auth_state.api_key_id
);
},
)?;
let payload: CreateWebhookRequest = serde_json::from_slice(&body)
.map_err(|e| CrawlRsError::Validation(format!("invalid JSON payload: {}", e)))?;
let team_id = auth_state.team_id;
match validate_url(&payload.url).await {
Ok(_) => {
log::debug!(
"Webhook URL passed SSRF validation url={} team_id={}",
crate::utils::url_redaction::redact_webhook_url_for_log(&payload.url),
team_id
);
}
Err(e) => {
log::warn!(
"SSRF attack attempt blocked via webhook URL url={} team_id={} api_key_id={} error={}",
crate::utils::url_redaction::redact_webhook_url_for_log(&payload.url),
team_id,
auth_state.api_key_id,
e
);
return Err(CrawlRsError::Validation(
"Invalid webhook URL: potential security risk detected".to_string(),
));
}
}
let use_case = CreateWebhookUseCase::new(repo);
let webhook = use_case.execute(team_id, payload.url).await?;
let response = WebhookResponse {
id: webhook.id,
team_id: webhook.team_id,
url: webhook.url,
created_at: webhook.created_at,
is_active: true,
secret: Some(settings.webhook.secret().to_string()),
};
Ok(success_response(StatusCode::CREATED, response))
}
pub async fn list_webhooks<R: WebhookRepository>(
Extension(repo): Extension<Arc<R>>,
Extension(auth_state): Extension<AuthState>,
) -> Result<Json<ApiResponse<WebhookListResponse>>, CrawlRsError> {
let team_id = auth_state.team_id;
let webhooks = repo.find_by_team_id(team_id).await?;
let webhook_entries: Vec<WebhookListEntry> = webhooks
.into_iter()
.map(|w| WebhookListEntry {
id: w.id,
team_id: w.team_id,
url: w.url,
created_at: w.created_at,
is_active: true,
})
.collect();
let total = webhook_entries.len();
Ok(Json(ApiResponse::success(WebhookListResponse {
webhooks: webhook_entries,
total,
})))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::application::dto::webhook_request::WebhookResponse;
use crate::domain::auth::ApiKeyScope;
use crate::domain::models::Webhook;
use crate::domain::repositories::task_repository::RepositoryError;
use crate::domain::services::rate_limiting_service::{
BacklogService, ConcurrencyConfig, ConcurrencyControlService, ConcurrencyResult,
QuotaService, RateLimitConfig, RateLimitResult, RateLimitService, RateLimitingError,
};
use async_trait::async_trait;
use chrono::Utc;
use dbnexus::DbPool;
use standardwebhooks::Webhook as StandardWebhook;
use std::sync::Mutex;
const TEST_WEBHOOK_SECRET: &str = "test-webhook-secret-key-32-chars-long!!";
fn make_test_settings_with_secret(secret: &str) -> Arc<Settings> {
let mut settings = Settings::default();
settings.webhook.secret = secret.to_string();
#[cfg(feature = "auth")]
{
settings.auth = crate::config::settings::AuthSettings {
jwt_secret: "a-very-strong-and-secure-jwt-secret-key-32+chars".to_string(),
};
}
crate::config::security::validate_security(&settings)
.expect("test webhook secret must satisfy validate_security requirements");
Arc::new(settings)
}
fn make_test_signature(secret: &str, msg_id: &str, payload: &str, timestamp: i64) -> String {
let wh = StandardWebhook::from_bytes(secret.as_bytes().to_vec())
.expect("valid standardwebhook key");
wh.sign(msg_id, timestamp, payload.as_bytes())
.expect("signing should succeed")
}
fn make_signed_headers(secret: &str, payload: &str) -> HeaderMap {
let timestamp = Utc::now().timestamp();
let msg_id = crate::domain::id::Id::generate().to_string();
let signature = make_test_signature(secret, &msg_id, payload, timestamp);
let mut headers = HeaderMap::new();
headers.insert(
SIGNATURE_HEADER,
axum::http::HeaderValue::from_str(&signature).expect("signature is valid header"),
);
headers.insert(
TIMESTAMP_HEADER,
axum::http::HeaderValue::from_str(×tamp.to_string())
.expect("timestamp is valid header"),
);
headers.insert(
MSG_ID_HEADER,
axum::http::HeaderValue::from_str(&msg_id).expect("msg_id is valid header"),
);
headers
}
#[test]
fn test_create_webhook_request_valid() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"url":"https://example.com/webhook"}"#;
let req: CreateWebhookRequest = serde_json::from_str(json).unwrap();
assert_eq!(req.url, "https://example.com/webhook");
}
#[test]
fn test_create_webhook_request_rejects_unknown_fields() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"url":"https://example.com","extra":"field"}"#;
let result: Result<CreateWebhookRequest, _> = serde_json::from_str(json);
assert!(result.is_err());
}
#[test]
fn test_create_webhook_request_serialization() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let req = CreateWebhookRequest {
url: "https://example.com/hook".to_string(),
};
let json = serde_json::to_string(&req).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["url"], "https://example.com/hook");
}
#[test]
fn test_create_webhook_request_round_trip() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let original = CreateWebhookRequest {
url: "https://my.webhook.site/abc123".to_string(),
};
let json = serde_json::to_string(&original).unwrap();
let deserialized: CreateWebhookRequest = serde_json::from_str(&json).unwrap();
assert_eq!(deserialized.url, original.url);
}
#[test]
fn test_webhook_to_response_mapping() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let webhook_id = crate::domain::id::Id::generate();
let team_id = crate::domain::id::Id::generate();
let webhook = Webhook {
id: webhook_id,
team_id,
url: "https://example.com/hook".to_string(),
created_at: Utc::now(),
};
let response = WebhookResponse {
id: webhook.id,
team_id: webhook.team_id,
url: webhook.url.clone(),
created_at: webhook.created_at,
is_active: true,
secret: None,
};
assert_eq!(response.id, webhook_id);
assert_eq!(response.team_id, team_id);
assert_eq!(response.url, "https://example.com/hook");
assert!(response.is_active);
assert!(response.secret.is_none());
}
#[test]
fn test_webhook_response_serialization() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let response = WebhookResponse {
id: crate::domain::id::Id::generate(),
team_id: crate::domain::id::Id::generate(),
url: "https://example.com/hook".to_string(),
created_at: Utc::now(),
is_active: true,
secret: Some("secret123".to_string()),
};
let json = serde_json::to_string(&response).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["url"], "https://example.com/hook");
assert_eq!(parsed["is_active"], true);
assert_eq!(parsed["secret"], "secret123");
}
#[test]
fn test_webhook_response_secret_none_serialized() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let response = WebhookResponse {
id: crate::domain::id::Id::generate(),
team_id: crate::domain::id::Id::generate(),
url: "https://example.com/hook".to_string(),
created_at: Utc::now(),
is_active: false,
secret: None,
};
let json = serde_json::to_string(&response).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["is_active"], false);
assert!(parsed["secret"].is_null());
}
#[test]
fn test_webhook_list_response_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let response = WebhookListResponse {
webhooks: vec![],
total: 0,
};
let json = serde_json::to_string(&response).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["total"], 0);
assert_eq!(parsed["webhooks"], serde_json::Value::Array(vec![]));
}
#[test]
fn test_webhook_list_response_with_items() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let webhook1 = WebhookListEntry {
id: crate::domain::id::Id::generate(),
team_id: crate::domain::id::Id::generate(),
url: "https://hook1.example.com".to_string(),
created_at: Utc::now(),
is_active: true,
};
let webhook2 = WebhookListEntry {
id: crate::domain::id::Id::generate(),
team_id: crate::domain::id::Id::generate(),
url: "https://hook2.example.com".to_string(),
created_at: Utc::now(),
is_active: false,
};
let response = WebhookListResponse {
webhooks: vec![webhook1, webhook2],
total: 2,
};
let json = serde_json::to_string(&response).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["total"], 2);
assert_eq!(parsed["webhooks"].as_array().unwrap().len(), 2);
assert_eq!(parsed["webhooks"][0]["url"], "https://hook1.example.com");
assert_eq!(parsed["webhooks"][1]["url"], "https://hook2.example.com");
}
#[test]
fn test_webhook_list_response_total_matches_count() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let webhooks: Vec<WebhookListEntry> = (0..5)
.map(|_| WebhookListEntry {
id: crate::domain::id::Id::generate(),
team_id: crate::domain::id::Id::generate(),
url: "https://example.com".to_string(),
created_at: Utc::now(),
is_active: true,
})
.collect();
let count = webhooks.len();
let response = WebhookListResponse {
webhooks,
total: count,
};
assert_eq!(response.total, 5);
assert_eq!(response.webhooks.len(), 5);
}
#[test]
fn test_webhook_new_constructor() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let id = crate::domain::id::Id::generate();
let team_id = crate::domain::id::Id::generate();
let webhook = Webhook::new(id, team_id, "https://example.com/hook".to_string());
assert_eq!(webhook.id, id);
assert_eq!(webhook.team_id, team_id);
assert_eq!(webhook.url, "https://example.com/hook");
assert!(webhook.created_at <= Utc::now());
}
fn make_test_db_pool() -> Arc<DbPool> {
crate::common::test_helpers::create_test_db_pool()
}
fn make_test_auth_state() -> AuthState {
AuthState::new(
make_test_db_pool(),
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
)
}
struct MockWebhookRepository {
create_error: Mutex<Option<RepositoryError>>,
find_by_team_id_result: Mutex<Option<Result<Vec<Webhook>, RepositoryError>>>,
}
impl MockWebhookRepository {
fn new() -> Self {
Self {
create_error: Mutex::new(None),
find_by_team_id_result: Mutex::new(None),
}
}
fn with_create_error(err: RepositoryError) -> Self {
Self {
create_error: Mutex::new(Some(err)),
find_by_team_id_result: Mutex::new(None),
}
}
fn with_find_result(result: Result<Vec<Webhook>, RepositoryError>) -> Self {
Self {
create_error: Mutex::new(None),
find_by_team_id_result: Mutex::new(Some(result)),
}
}
}
#[async_trait]
impl WebhookRepository for MockWebhookRepository {
async fn create(&self, webhook: &Webhook) -> Result<Webhook, RepositoryError> {
if let Some(err) = self.create_error.lock().unwrap().take() {
return Err(err);
}
Ok(webhook.clone())
}
async fn find_by_id(
&self,
_id: crate::domain::id::Id,
) -> Result<Option<Webhook>, RepositoryError> {
Ok(None)
}
async fn find_by_team_id(
&self,
_team_id: crate::domain::id::Id,
) -> Result<Vec<Webhook>, RepositoryError> {
match self.find_by_team_id_result.lock().unwrap().take() {
Some(result) => result,
None => Ok(vec![]),
}
}
}
struct MockRateLimitingService {
rate_limit_result: RateLimitResult,
}
impl MockRateLimitingService {
fn new_allowed() -> Self {
Self {
rate_limit_result: RateLimitResult::Allowed,
}
}
fn new_denied(reason: &str) -> Self {
Self {
rate_limit_result: RateLimitResult::Denied {
reason: reason.to_string(),
},
}
}
}
#[async_trait]
impl RateLimitService for MockRateLimitingService {
async fn check_rate_limit(
&self,
_api_key: &str,
_endpoint: &str,
) -> Result<RateLimitResult, RateLimitingError> {
Ok(self.rate_limit_result.clone())
}
async fn get_team_rate_limit_config(
&self,
_team_id: crate::domain::id::Id,
) -> Result<RateLimitConfig, RateLimitingError> {
Ok(RateLimitConfig::default())
}
async fn update_team_rate_limit_config(
&self,
_team_id: crate::domain::id::Id,
_config: RateLimitConfig,
) -> Result<(), RateLimitingError> {
Ok(())
}
async fn cleanup_expired_rate_limits(&self) -> Result<u64, RateLimitingError> {
Ok(0)
}
}
#[async_trait]
impl ConcurrencyControlService for MockRateLimitingService {
async fn check_team_concurrency(
&self,
_team_id: crate::domain::id::Id,
_task_id: crate::domain::id::Id,
) -> Result<ConcurrencyResult, RateLimitingError> {
Ok(ConcurrencyResult::Allowed)
}
async fn release_team_concurrency_slot(
&self,
_team_id: crate::domain::id::Id,
_task_id: crate::domain::id::Id,
) -> Result<(), RateLimitingError> {
Ok(())
}
async fn get_team_current_concurrency(
&self,
_team_id: crate::domain::id::Id,
) -> Result<u32, RateLimitingError> {
Ok(0)
}
async fn get_team_concurrency_config(
&self,
_team_id: crate::domain::id::Id,
) -> Result<ConcurrencyConfig, RateLimitingError> {
Ok(ConcurrencyConfig::default())
}
async fn update_team_concurrency_config(
&self,
_team_id: crate::domain::id::Id,
_config: ConcurrencyConfig,
) -> Result<(), RateLimitingError> {
Ok(())
}
}
#[async_trait]
impl BacklogService for MockRateLimitingService {
async fn process_backlog_tasks(
&self,
_team_id: crate::domain::id::Id,
) -> Result<u32, RateLimitingError> {
Ok(0)
}
}
#[async_trait]
impl QuotaService for MockRateLimitingService {
async fn check_and_deduct_quota(
&self,
_team_id: crate::domain::id::Id,
_amount: i64,
_transaction_type: crate::domain::models::CreditsTransactionType,
_description: String,
_reference_id: Option<crate::domain::id::Id>,
) -> Result<(), RateLimitingError> {
Ok(())
}
async fn get_quota_balance(
&self,
_team_id: crate::domain::id::Id,
) -> Result<i64, RateLimitingError> {
Ok(0)
}
async fn refund_quota(
&self,
_team_id: crate::domain::id::Id,
_amount: i64,
_description: String,
_reference_id: Option<crate::domain::id::Id>,
) -> Result<(), RateLimitingError> {
Ok(())
}
}
impl RateLimitingService for MockRateLimitingService {}
#[tokio::test]
async fn test_create_webhook_success() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::new());
let rate_limit = Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let team_id = auth.team_id;
let payload = CreateWebhookRequest {
url: "https://example.com/webhook".to_string(),
};
let payload_bytes = serde_json::to_vec(&payload).expect("serialize payload");
let settings = make_test_settings_with_secret(TEST_WEBHOOK_SECRET);
let headers = make_signed_headers(
TEST_WEBHOOK_SECRET,
std::str::from_utf8(&payload_bytes).expect("utf8"),
);
let result = create_webhook(
Extension(repo),
Extension(rate_limit as Arc<dyn RateLimitingService>),
Extension(auth),
Extension(settings),
headers,
Bytes::from(payload_bytes),
)
.await;
assert!(result.is_ok(), "create_webhook should succeed");
let response = result.unwrap();
assert_eq!(response.status(), StatusCode::CREATED);
let bytes = axum::body::to_bytes(response.into_body(), 64 * 1024)
.await
.expect("read body");
let parsed: serde_json::Value = serde_json::from_slice(&bytes).expect("json body");
assert_eq!(parsed["success"], true, "创建响应走 success/data 包封");
assert_eq!(parsed["data"]["team_id"], team_id.to_string());
assert_eq!(parsed["data"]["url"], "https://example.com/webhook");
assert_eq!(parsed["data"]["is_active"], true);
assert_eq!(
parsed["data"]["secret"], TEST_WEBHOOK_SECRET,
"创建响应必须一次性返回签名密钥(送达验签依赖)"
);
}
#[tokio::test]
async fn test_create_webhook_ssrf_blocked() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::new());
let rate_limit = Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let payload = CreateWebhookRequest {
url: "http://127.0.0.1:8080".to_string(),
};
let payload_bytes = serde_json::to_vec(&payload).expect("serialize payload");
let settings = make_test_settings_with_secret(TEST_WEBHOOK_SECRET);
let headers = make_signed_headers(
TEST_WEBHOOK_SECRET,
std::str::from_utf8(&payload_bytes).expect("utf8"),
);
let result = create_webhook(
Extension(repo),
Extension(rate_limit as Arc<dyn RateLimitingService>),
Extension(auth),
Extension(settings),
headers,
Bytes::from(payload_bytes),
)
.await;
assert!(result.is_err(), "SSRF URL should be rejected");
match result.unwrap_err() {
CrawlRsError::Validation(msg) => {
assert!(
msg.contains("Invalid webhook URL"),
"expected SSRF validation message, got: {}",
msg
);
}
other => panic!("expected CrawlRsError::Validation, got {:?}", other),
}
}
#[tokio::test]
async fn test_create_webhook_rate_limit_exceeded() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::new());
let rate_limit = Arc::new(MockRateLimitingService::new_denied("too many requests"));
let auth = make_test_auth_state();
let payload = CreateWebhookRequest {
url: "https://example.com/webhook".to_string(),
};
let payload_bytes = serde_json::to_vec(&payload).expect("serialize payload");
let settings = make_test_settings_with_secret(TEST_WEBHOOK_SECRET);
let headers = make_signed_headers(
TEST_WEBHOOK_SECRET,
std::str::from_utf8(&payload_bytes).expect("utf8"),
);
let result = create_webhook(
Extension(repo),
Extension(rate_limit as Arc<dyn RateLimitingService>),
Extension(auth),
Extension(settings),
headers,
Bytes::from(payload_bytes),
)
.await;
assert!(result.is_err(), "rate-limited request should fail");
match result.unwrap_err() {
CrawlRsError::RateLimit(msg) => {
assert!(
msg.contains("Rate limit exceeded"),
"expected rate limit message, got: {}",
msg
);
}
other => panic!("expected CrawlRsError::RateLimit, got {:?}", other),
}
}
#[tokio::test]
async fn test_create_webhook_repo_create_failure() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::with_create_error(
RepositoryError::Database(anyhow::anyhow!("repo down")),
));
let rate_limit = Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let payload = CreateWebhookRequest {
url: "https://example.com/webhook".to_string(),
};
let payload_bytes = serde_json::to_vec(&payload).expect("serialize payload");
let settings = make_test_settings_with_secret(TEST_WEBHOOK_SECRET);
let headers = make_signed_headers(
TEST_WEBHOOK_SECRET,
std::str::from_utf8(&payload_bytes).expect("utf8"),
);
let result = create_webhook(
Extension(repo),
Extension(rate_limit as Arc<dyn RateLimitingService>),
Extension(auth),
Extension(settings),
headers,
Bytes::from(payload_bytes),
)
.await;
assert!(result.is_err(), "repo failure should propagate");
match result.unwrap_err() {
CrawlRsError::Other(msg) => {
assert!(
msg.contains("repo down"),
"expected repo failure message, got: {}",
msg
);
}
other => panic!("expected CrawlRsError::Other, got {:?}", other),
}
}
#[tokio::test]
async fn test_list_webhooks_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::new());
let auth = make_test_auth_state();
let result = list_webhooks::<MockWebhookRepository>(Extension(repo), Extension(auth)).await;
assert!(
result.is_ok(),
"list_webhooks should succeed for empty list"
);
let response = result.unwrap();
let data = response
.data
.as_ref()
.expect("response data should be present");
assert_eq!(data.total, 0);
assert!(data.webhooks.is_empty());
}
#[tokio::test]
async fn test_list_webhooks_with_items() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let team_id = crate::domain::id::Id::generate();
let webhook1 = Webhook::new(
crate::domain::id::Id::generate(),
team_id,
"https://hook1.example.com".to_string(),
);
let webhook2 = Webhook::new(
crate::domain::id::Id::generate(),
team_id,
"https://hook2.example.com".to_string(),
);
let repo = Arc::new(MockWebhookRepository::with_find_result(Ok(vec![
webhook1.clone(),
webhook2.clone(),
])));
let auth = make_test_auth_state();
let result = list_webhooks::<MockWebhookRepository>(Extension(repo), Extension(auth)).await;
assert!(result.is_ok(), "list_webhooks should succeed with items");
let response = result.unwrap();
let data = response
.data
.as_ref()
.expect("response data should be present");
assert_eq!(data.total, 2);
assert_eq!(data.webhooks.len(), 2);
assert_eq!(data.webhooks[0].url, "https://hook1.example.com");
assert_eq!(data.webhooks[1].url, "https://hook2.example.com");
}
#[tokio::test]
async fn test_list_webhooks_repo_failure() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::with_find_result(Err(
RepositoryError::Database(anyhow::anyhow!("find_by_team_id failed")),
)));
let auth = make_test_auth_state();
let result = list_webhooks::<MockWebhookRepository>(Extension(repo), Extension(auth)).await;
assert!(result.is_err(), "repo failure should propagate");
match result.unwrap_err() {
CrawlRsError::Other(msg) => {
assert!(
msg.contains("find_by_team_id failed"),
"expected repo failure message, got: {}",
msg
);
}
other => panic!("expected CrawlRsError::Other, got {:?}", other),
}
}
use crate::test_utils::ensure_debug_logger;
#[tokio::test]
async fn test_create_webhook_debug_log_evaluated() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
ensure_debug_logger();
let repo = Arc::new(MockWebhookRepository::new());
let rate_limit = Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let payload = CreateWebhookRequest {
url: "https://example.com/webhook".to_string(),
};
let payload_bytes = serde_json::to_vec(&payload).expect("serialize payload");
let settings = make_test_settings_with_secret(TEST_WEBHOOK_SECRET);
let headers = make_signed_headers(
TEST_WEBHOOK_SECRET,
std::str::from_utf8(&payload_bytes).expect("utf8"),
);
let result = create_webhook(
Extension(repo),
Extension(rate_limit as Arc<dyn RateLimitingService>),
Extension(auth),
Extension(settings),
headers,
Bytes::from(payload_bytes),
)
.await;
assert!(result.is_ok());
let response = result.unwrap();
assert_eq!(response.status(), StatusCode::CREATED);
let bytes = axum::body::to_bytes(response.into_body(), 64 * 1024)
.await
.expect("read body");
let parsed: serde_json::Value = serde_json::from_slice(&bytes).expect("json body");
assert_eq!(parsed["data"]["url"], "https://example.com/webhook");
}
fn make_headers_with_signature_and_timestamp(signature: &str, timestamp: i64) -> HeaderMap {
let mut headers = HeaderMap::new();
headers.insert(
SIGNATURE_HEADER,
axum::http::HeaderValue::from_str(signature).expect("signature is valid header"),
);
headers.insert(
TIMESTAMP_HEADER,
axum::http::HeaderValue::from_str(×tamp.to_string())
.expect("timestamp is valid header"),
);
headers
}
#[tokio::test]
async fn test_create_webhook_missing_signature_header_returns_401() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::new());
let rate_limit = Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let payload = CreateWebhookRequest {
url: "https://example.com/webhook".to_string(),
};
let payload_bytes = serde_json::to_vec(&payload).expect("serialize payload");
let settings = make_test_settings_with_secret(TEST_WEBHOOK_SECRET);
let mut headers = HeaderMap::new();
headers.insert(
TIMESTAMP_HEADER,
axum::http::HeaderValue::from_str(&Utc::now().timestamp().to_string())
.expect("timestamp is valid header"),
);
let result = create_webhook(
Extension(repo),
Extension(rate_limit as Arc<dyn RateLimitingService>),
Extension(auth),
Extension(settings),
headers,
Bytes::from(payload_bytes),
)
.await;
assert!(result.is_err(), "missing signature header should fail");
match result.unwrap_err() {
CrawlRsError::Authentication(msg) => {
assert!(
msg.contains(WEBHOOK_AUTH_FAILED),
"expected unified auth failure message, got: {}",
msg
);
}
other => panic!("expected CrawlRsError::Authentication, got {:?}", other),
}
}
#[tokio::test]
async fn test_create_webhook_missing_timestamp_header_returns_401() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::new());
let rate_limit = Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let payload = CreateWebhookRequest {
url: "https://example.com/webhook".to_string(),
};
let payload_bytes = serde_json::to_vec(&payload).expect("serialize payload");
let settings = make_test_settings_with_secret(TEST_WEBHOOK_SECRET);
let mut headers = HeaderMap::new();
headers.insert(
SIGNATURE_HEADER,
axum::http::HeaderValue::from_static("deadbeef"),
);
let result = create_webhook(
Extension(repo),
Extension(rate_limit as Arc<dyn RateLimitingService>),
Extension(auth),
Extension(settings),
headers,
Bytes::from(payload_bytes),
)
.await;
assert!(result.is_err(), "missing timestamp header should fail");
match result.unwrap_err() {
CrawlRsError::Authentication(msg) => {
assert!(
msg.contains(WEBHOOK_AUTH_FAILED),
"expected unified auth failure message, got: {}",
msg
);
}
other => panic!("expected CrawlRsError::Authentication, got {:?}", other),
}
}
#[tokio::test]
async fn test_create_webhook_invalid_timestamp_format_returns_401() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::new());
let rate_limit = Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let payload = CreateWebhookRequest {
url: "https://example.com/webhook".to_string(),
};
let payload_bytes = serde_json::to_vec(&payload).expect("serialize payload");
let settings = make_test_settings_with_secret(TEST_WEBHOOK_SECRET);
let mut headers = HeaderMap::new();
headers.insert(
SIGNATURE_HEADER,
axum::http::HeaderValue::from_static("deadbeef"),
);
headers.insert(
TIMESTAMP_HEADER,
axum::http::HeaderValue::from_static("not-a-number"),
);
let result = create_webhook(
Extension(repo),
Extension(rate_limit as Arc<dyn RateLimitingService>),
Extension(auth),
Extension(settings),
headers,
Bytes::from(payload_bytes),
)
.await;
assert!(result.is_err(), "invalid timestamp format should fail");
match result.unwrap_err() {
CrawlRsError::Authentication(msg) => {
assert!(
msg.contains(WEBHOOK_AUTH_FAILED),
"expected unified auth failure message, got: {}",
msg
);
}
other => panic!("expected CrawlRsError::Authentication, got {:?}", other),
}
}
#[tokio::test]
async fn test_create_webhook_wrong_signature_returns_401() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::new());
let rate_limit = Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let payload = CreateWebhookRequest {
url: "https://example.com/webhook".to_string(),
};
let payload_bytes = serde_json::to_vec(&payload).expect("serialize payload");
let settings = make_test_settings_with_secret(TEST_WEBHOOK_SECRET);
let headers =
make_headers_with_signature_and_timestamp("deadbeefcafebabe", Utc::now().timestamp());
let result = create_webhook(
Extension(repo),
Extension(rate_limit as Arc<dyn RateLimitingService>),
Extension(auth),
Extension(settings),
headers,
Bytes::from(payload_bytes),
)
.await;
assert!(result.is_err(), "wrong signature should fail");
match result.unwrap_err() {
CrawlRsError::Authentication(msg) => {
assert!(
msg.contains(WEBHOOK_AUTH_FAILED),
"expected unified auth failure message, got: {}",
msg
);
}
other => panic!("expected CrawlRsError::Authentication, got {:?}", other),
}
}
#[tokio::test]
async fn test_create_webhook_expired_timestamp_returns_401() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::new());
let rate_limit = Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let payload = CreateWebhookRequest {
url: "https://example.com/webhook".to_string(),
};
let payload_bytes = serde_json::to_vec(&payload).expect("serialize payload");
let settings = make_test_settings_with_secret(TEST_WEBHOOK_SECRET);
let expired_timestamp = Utc::now().timestamp() - 600;
let payload_str = std::str::from_utf8(&payload_bytes).expect("utf8");
let signature =
make_test_signature(TEST_WEBHOOK_SECRET, "none", payload_str, expired_timestamp);
let headers = make_headers_with_signature_and_timestamp(&signature, expired_timestamp);
let result = create_webhook(
Extension(repo),
Extension(rate_limit as Arc<dyn RateLimitingService>),
Extension(auth),
Extension(settings),
headers,
Bytes::from(payload_bytes),
)
.await;
assert!(result.is_err(), "expired timestamp should fail");
match result.unwrap_err() {
CrawlRsError::Authentication(msg) => {
assert!(
msg.contains(WEBHOOK_AUTH_FAILED),
"expected unified auth failure message, got: {}",
msg
);
}
other => panic!("expected CrawlRsError::Authentication, got {:?}", other),
}
}
#[tokio::test]
async fn test_create_webhook_wrong_secret_returns_401() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::new());
let rate_limit = Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let payload = CreateWebhookRequest {
url: "https://example.com/webhook".to_string(),
};
let payload_bytes = serde_json::to_vec(&payload).expect("serialize payload");
let server_secret = "server-side-secret-32-chars-long-xxxx";
let client_secret = "client-side-secret-32-chars-long-xxxx";
let settings = make_test_settings_with_secret(server_secret);
let payload_str = std::str::from_utf8(&payload_bytes).expect("utf8");
let timestamp = Utc::now().timestamp();
let signature = make_test_signature(client_secret, "none", payload_str, timestamp);
let headers = make_headers_with_signature_and_timestamp(&signature, timestamp);
let result = create_webhook(
Extension(repo),
Extension(rate_limit as Arc<dyn RateLimitingService>),
Extension(auth),
Extension(settings),
headers,
Bytes::from(payload_bytes),
)
.await;
assert!(result.is_err(), "wrong secret signature should fail");
match result.unwrap_err() {
CrawlRsError::Authentication(msg) => {
assert!(
msg.contains(WEBHOOK_AUTH_FAILED),
"expected unified auth failure message, got: {}",
msg
);
}
other => panic!("expected CrawlRsError::Authentication, got {:?}", other),
}
}
#[tokio::test]
async fn test_create_webhook_invalid_utf8_body_returns_401() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockWebhookRepository::new());
let rate_limit = Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let settings = make_test_settings_with_secret(TEST_WEBHOOK_SECRET);
let invalid_utf8_bytes: Vec<u8> = vec![0xff, 0xfe, 0xfd, 0x00];
let headers = make_signed_headers(
TEST_WEBHOOK_SECRET,
std::str::from_utf8(&invalid_utf8_bytes).unwrap_or(""),
);
let result = create_webhook(
Extension(repo),
Extension(rate_limit as Arc<dyn RateLimitingService>),
Extension(auth),
Extension(settings),
headers,
Bytes::from(invalid_utf8_bytes),
)
.await;
assert!(result.is_err(), "invalid UTF-8 body should fail");
match result.unwrap_err() {
CrawlRsError::Authentication(msg) => {
assert!(
msg.contains(WEBHOOK_AUTH_FAILED),
"expected unified auth failure message, got: {}",
msg
);
}
other => panic!("expected CrawlRsError::Authentication, got {:?}", other),
}
}
}