:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
use anyhow::Result;
use governor::clock::FakeRelativeClock;
use reqwest::StatusCode;
use serde_json::json;
use std::collections::HashMap;
use std::time::Duration;
use crate::common::*;
use feature_flags::config::{Config, FlexBool};
use feature_flags::utils::test_utils::{
insert_config_in_hypercache, insert_new_team_in_redis, setup_redis_client, TestContext,
};
pub mod common;
#[tokio::test]
async fn test_rate_limit_basic() -> Result<()> {
// Create config with very restrictive rate limiting (capacity: 3, replenish: 0.1/sec)
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(false); // Actually block requests
config.flags_bucket_capacity = 3;
config.flags_bucket_replenish_rate = 0.1;
// Set up team and token in Redis and Postgres
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
// Insert config into hypercache (required for default config=true behavior)
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
// Prepare request payload with valid token
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// First 3 requests should succeed (burst capacity)
for i in 1..=3 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed"
);
}
// 4th request should be rate limited
let rate_limited_response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
rate_limited_response.status(),
StatusCode::TOO_MANY_REQUESTS,
"4th request should be rate limited"
);
// Verify response format matches Python's /decide endpoint
let response_body: serde_json::Value = rate_limited_response.json().await?;
assert_eq!(response_body["type"], "validation_error");
assert_eq!(response_body["code"], "rate_limit_exceeded");
assert_eq!(response_body["detail"], "Rate limit exceeded");
assert!(response_body["attr"].is_null());
Ok(())
}
#[tokio::test]
async fn test_rate_limit_disabled() -> Result<()> {
// Create config with rate limiting disabled (default)
let config = Config::default_test_config();
assert!(!*config.flags_rate_limit_enabled);
// Set up team and token
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
// Insert config into hypercache (required for default config=true behavior)
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// When disabled, all requests should succeed
for i in 1..=10 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed when rate limiting is disabled"
);
}
Ok(())
}
#[tokio::test]
async fn test_rate_limit_per_token_isolation() -> Result<()> {
// Create config with capacity of 1
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(false);
config.flags_bucket_capacity = 1;
config.flags_bucket_replenish_rate = 0.1;
// Set up two teams with different tokens
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team1 = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token1 = team1.api_token.clone();
let team2 = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token2 = team2.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team1.id)).await.unwrap();
context
.insert_person(team1.id, "user1".to_string(), None)
.await
.unwrap();
context.insert_new_team(Some(team2.id)).await.unwrap();
context
.insert_person(team2.id, "user2".to_string(), None)
.await
.unwrap();
// Insert config into hypercache for both teams
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token1, remote_config.clone()).await?;
insert_config_in_hypercache(redis_client.clone(), &token2, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload1 = json!({
"token": token1,
"distinct_id": "user1",
});
let payload2 = json!({
"token": token2,
"distinct_id": "user2",
});
// First token's first request should succeed
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload1)
.send()
.await?;
assert_eq!(response.status(), StatusCode::OK);
// First token's second request should be rate limited
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload1)
.send()
.await?;
assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);
// Second token's first request should succeed (different bucket)
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload2)
.send()
.await?;
assert_eq!(response.status(), StatusCode::OK);
// Second token's second request should be rate limited
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload2)
.send()
.await?;
assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);
Ok(())
}
#[tokio::test]
async fn test_rate_limit_with_invalid_tokens() -> Result<()> {
// Create config with very restrictive rate limiting
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(false);
config.flags_bucket_capacity = 3;
config.flags_bucket_replenish_rate = 0.01;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": "invalid_token",
"distinct_id": "user123",
});
// First 3 requests with invalid token should return 401 (not rate limited yet)
for i in 1..=3 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
// Rate limiting happens before authentication
// So the first 3 requests pass rate limit but fail authentication
assert_eq!(
response.status(),
StatusCode::UNAUTHORIZED,
"Request {i} should fail authentication"
);
}
// 4th request should be rate limited (before authentication)
let rate_limited_response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
rate_limited_response.status(),
StatusCode::TOO_MANY_REQUESTS,
"4th request should be rate limited before authentication"
);
let response_body: serde_json::Value = rate_limited_response.json().await?;
assert_eq!(response_body["code"], "rate_limit_exceeded");
Ok(())
}
#[tokio::test]
async fn test_rate_limit_ip_fallback_on_malformed_body() -> Result<()> {
// Test that IP is used for rate limiting when body parsing fails
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(false);
config.flags_bucket_capacity = 2;
config.flags_bucket_replenish_rate = 0.1;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
// Send malformed JSON body
let malformed_body = "not valid json";
// First 2 requests should pass rate limit (but fail parsing)
for i in 1..=2 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.body(malformed_body)
.send()
.await?;
// Should get some error (not rate limited)
assert_ne!(
response.status(),
StatusCode::TOO_MANY_REQUESTS,
"Request {i} should not be rate limited (falls back to IP)"
);
}
// 3rd request should be rate limited (IP-based bucket exhausted)
let rate_limited_response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.body(malformed_body)
.send()
.await?;
assert_eq!(
rate_limited_response.status(),
StatusCode::TOO_MANY_REQUESTS,
"3rd request should be rate limited using IP as key"
);
Ok(())
}
#[tokio::test]
async fn test_rate_limit_replenishment() -> Result<()> {
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(false);
config.flags_bucket_capacity = 1;
config.flags_bucket_replenish_rate = 1.0;
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let clock = FakeRelativeClock::default();
let server = ServerHandle::for_config_with_rate_limiter_clock(config, clock.clone()).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(response.status(), StatusCode::OK, "First request allowed");
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::TOO_MANY_REQUESTS,
"Second request blocked"
);
clock.advance(Duration::from_secs(1));
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Third request allowed after replenishment"
);
Ok(())
}
#[tokio::test]
async fn test_ip_rate_limit_basic() -> Result<()> {
// Create config with IP rate limiting enabled
let mut config = Config::default_test_config();
config.flags_ip_rate_limit_enabled = FlexBool(true);
config.flags_ip_rate_limit_log_only = FlexBool(false);
config.flags_ip_burst_size = 3;
config.flags_ip_replenish_rate = 0.1;
// Set up team and token
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
// Insert config into hypercache
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// First 3 requests should succeed (IP burst capacity)
for i in 1..=3 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed"
);
}
// 4th request should be rate limited by IP
let rate_limited_response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
rate_limited_response.status(),
StatusCode::TOO_MANY_REQUESTS,
"4th request should be rate limited by IP"
);
// Verify JSON response format matches token-based rate limiter
let error_json: serde_json::Value = rate_limited_response.json().await?;
assert_eq!(error_json["type"], "validation_error");
assert_eq!(error_json["code"], "rate_limit_exceeded");
assert_eq!(error_json["detail"], "Rate limit exceeded");
Ok(())
}
#[tokio::test]
async fn test_ip_rate_limit_with_rotating_tokens() -> Result<()> {
// Test that IP rate limiting prevents DDoS with rotating fake tokens
let mut config = Config::default_test_config();
config.flags_ip_rate_limit_enabled = FlexBool(true);
config.flags_ip_rate_limit_log_only = FlexBool(false);
config.flags_ip_burst_size = 5;
config.flags_ip_replenish_rate = 0.1;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
// Send 5 requests with different fake tokens (all from same IP)
for i in 1..=5 {
let payload = json!({
"token": format!("fake_token_{i}"),
"distinct_id": "user123",
});
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
// These will fail authentication, but should pass IP rate limit
assert_ne!(
response.status(),
StatusCode::TOO_MANY_REQUESTS,
"Request {i} with fake token should not be IP rate limited yet"
);
}
// 6th request should be IP rate limited (regardless of token)
let payload = json!({
"token": "fake_token_6",
"distinct_id": "user123",
});
let rate_limited_response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
rate_limited_response.status(),
StatusCode::TOO_MANY_REQUESTS,
"6th request should be IP rate limited despite different token"
);
Ok(())
}
#[tokio::test]
async fn test_both_rate_limiters_together() -> Result<()> {
// Test that both token-based and IP-based rate limiting work together
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(false);
config.flags_bucket_capacity = 2;
config.flags_bucket_replenish_rate = 0.1;
config.flags_ip_rate_limit_enabled = FlexBool(true);
config.flags_ip_rate_limit_log_only = FlexBool(false);
config.flags_ip_burst_size = 10;
config.flags_ip_replenish_rate = 1.0;
// Set up team and token
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
// Insert config into hypercache
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// First 2 requests should succeed (token bucket capacity)
for i in 1..=2 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed"
);
}
// 3rd request should be rate limited by token (not IP, since IP limit is 10)
let rate_limited_response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
rate_limited_response.status(),
StatusCode::TOO_MANY_REQUESTS,
"3rd request should be rate limited by token"
);
// Response should be the token-based rate limit error format
let response_body: serde_json::Value = rate_limited_response.json().await?;
assert_eq!(response_body["type"], "validation_error");
assert_eq!(response_body["code"], "rate_limit_exceeded");
Ok(())
}
#[tokio::test]
async fn test_ip_rate_limit_disabled() -> Result<()> {
// Verify IP rate limiting is disabled by default
let mut config = Config::default_test_config();
config.flags_ip_rate_limit_enabled = FlexBool(false);
// Set up team and token
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
// Insert config into hypercache
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// Should be able to make many requests without IP rate limiting
for i in 1..=20 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed when IP rate limiting is disabled"
);
}
Ok(())
}
#[tokio::test]
async fn test_ip_rate_limit_respects_x_forwarded_for() -> Result<()> {
// Test that IP rate limiting uses X-Forwarded-For header (production scenario)
let mut config = Config::default_test_config();
config.flags_ip_rate_limit_enabled = FlexBool(true);
config.flags_ip_rate_limit_log_only = FlexBool(false);
config.flags_ip_burst_size = 2;
config.flags_ip_replenish_rate = 0.1;
// Set up team and token
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
// Insert config into hypercache
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// Simulate requests from two different client IPs via X-Forwarded-For
let client_ip_1 = "203.0.113.1"; // Test IP 1
let client_ip_2 = "203.0.113.2"; // Test IP 2
// Client IP 1: First 2 requests should succeed
for i in 1..=2 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.header("X-Forwarded-For", client_ip_1)
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Client IP 1 request {i} should succeed"
);
}
// Client IP 1: 3rd request should be rate limited
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.header("X-Forwarded-For", client_ip_1)
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::TOO_MANY_REQUESTS,
"Client IP 1 should be rate limited after 2 requests"
);
// Client IP 2: Should have its own separate rate limit bucket
for i in 1..=2 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.header("X-Forwarded-For", client_ip_2)
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Client IP 2 request {i} should succeed (separate bucket)"
);
}
// Client IP 2: 3rd request should be rate limited
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.header("X-Forwarded-For", client_ip_2)
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::TOO_MANY_REQUESTS,
"Client IP 2 should be rate limited after 2 requests"
);
Ok(())
}
#[tokio::test]
async fn test_token_rate_limit_log_only_mode() -> Result<()> {
// Test that token-based rate limiting in log-only mode allows requests through
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(true); // Log-only mode
config.flags_bucket_capacity = 2;
config.flags_bucket_replenish_rate = 0.1;
// Set up team and token
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
// Insert config into hypercache
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// First 2 requests should succeed (within capacity)
for i in 1..=2 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed"
);
}
// Requests 3-5 should also succeed despite exceeding rate limit (log-only mode)
for i in 3..=5 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed in log-only mode despite exceeding rate limit"
);
}
Ok(())
}
#[tokio::test]
async fn test_ip_rate_limit_log_only_mode() -> Result<()> {
// Test that IP-based rate limiting in log-only mode allows requests through
let mut config = Config::default_test_config();
config.flags_ip_rate_limit_enabled = FlexBool(true);
config.flags_ip_rate_limit_log_only = FlexBool(true); // Log-only mode
config.flags_ip_burst_size = 2;
config.flags_ip_replenish_rate = 0.1;
// Set up team and token
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
// Insert config into hypercache
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// First 2 requests should succeed (within capacity)
for i in 1..=2 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed"
);
}
// Requests 3-5 should also succeed despite exceeding IP rate limit (log-only mode)
for i in 3..=5 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed in log-only mode despite exceeding IP rate limit"
);
}
Ok(())
}
#[tokio::test]
async fn test_mixed_log_only_modes() -> Result<()> {
// Test IP rate limiting in enforced mode while token rate limiting is in log-only mode
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(true); // Token: log-only
config.flags_bucket_capacity = 1;
config.flags_bucket_replenish_rate = 0.1;
config.flags_ip_rate_limit_enabled = FlexBool(true);
config.flags_ip_rate_limit_log_only = FlexBool(false); // IP: enforced
config.flags_ip_burst_size = 3;
config.flags_ip_replenish_rate = 0.1;
// Set up team and token
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
// Insert config into hypercache
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// First 3 requests should succeed (within IP burst capacity)
for i in 1..=3 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed (within IP limit)"
);
}
// 4th request should be rate limited by IP (enforced mode)
// even though token rate limiting is in log-only mode
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::TOO_MANY_REQUESTS,
"4th request should be IP rate limited (enforced mode takes precedence)"
);
Ok(())
}
#[tokio::test]
async fn test_rate_limit_warn_then_enforce() -> Result<()> {
// warn at 40% of 5 = 2, enforce at 5
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(false);
config.flags_warn_capacity_ratio = 0.4;
config.flags_bucket_capacity = 5;
config.flags_bucket_replenish_rate = 0.1;
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// Requests 1-2: within warn capacity → 200, no warning header
for i in 1..=2 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed"
);
assert!(
response
.headers()
.get("X-PostHog-Rate-Limit-Warning")
.is_none(),
"Request {i} should not have warning header"
);
}
// Requests 3-5: exceed warn but within enforce → 200 with warning header
for i in 3..=5 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed with warning"
);
assert_eq!(
response
.headers()
.get("X-PostHog-Rate-Limit-Warning")
.map(|v| v.to_str().unwrap()),
Some("true"),
"Request {i} should have warning header"
);
}
// Request 6: exceeds enforce → 429
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::TOO_MANY_REQUESTS,
"Request 6 should be blocked"
);
Ok(())
}
#[tokio::test]
async fn test_rate_limit_warn_header_absent_below_threshold() -> Result<()> {
// Verify the warning header is absent on normal responses
// warn at 50% of 200 = 100
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(false);
config.flags_warn_capacity_ratio = 0.5;
config.flags_bucket_capacity = 200;
config.flags_bucket_replenish_rate = 10.0;
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// A few requests well below the warn threshold
for i in 1..=3 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed"
);
assert!(
response
.headers()
.get("X-PostHog-Rate-Limit-Warning")
.is_none(),
"Request {i} should NOT have warning header when below threshold"
);
}
Ok(())
}
#[tokio::test]
async fn test_ip_rate_limit_warn_then_enforce() -> Result<()> {
let mut config = Config::default_test_config();
// warn at 50% of 4 = 2, enforce at 4
config.flags_ip_rate_limit_enabled = FlexBool(true);
config.flags_ip_rate_limit_log_only = FlexBool(false);
config.flags_warn_capacity_ratio = 0.5;
config.flags_ip_burst_size = 4;
config.flags_ip_replenish_rate = 0.1;
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// Requests 1-2: within warn capacity → 200, no header
for i in 1..=2 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(response.status(), StatusCode::OK, "Request {i}");
assert!(
response
.headers()
.get("X-PostHog-Rate-Limit-Warning")
.is_none(),
"Request {i} should not have warning header"
);
}
// Requests 3-4: exceed warn, within enforce → 200 with warning header
for i in 3..=4 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(response.status(), StatusCode::OK, "Request {i}");
assert_eq!(
response
.headers()
.get("X-PostHog-Rate-Limit-Warning")
.map(|v| v.to_str().unwrap()),
Some("true"),
"Request {i} should have warning header"
);
}
// Request 5: exceeds enforce → 429
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::TOO_MANY_REQUESTS,
"Request 5 should be blocked"
);
Ok(())
}
#[tokio::test]
async fn test_rate_limit_backwards_compat_log_only() -> Result<()> {
// When log_only=true, all requests should be allowed regardless of warn/enforce thresholds
// (matches today's behavior: log but don't block)
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(true);
config.flags_bucket_capacity = 2;
config.flags_bucket_replenish_rate = 0.1;
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// With capacity=2 and default warn_ratio=0.8, warn capacity = floor(2*0.8) = 1.
// Request 1: within both thresholds → 200, no warning header
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request 1 should succeed"
);
assert!(
response
.headers()
.get("X-PostHog-Rate-Limit-Warning")
.is_none(),
"Request 1 should not have warning header"
);
// Requests 2-5: exceed warn or enforce thresholds → 200 with warning header
// (log_only mode converts all rejections to warnings)
for i in 2..=5 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed in backwards-compat log-only mode"
);
assert_eq!(
response
.headers()
.get("X-PostHog-Rate-Limit-Warning")
.map(|v| v.to_str().unwrap()),
Some("true"),
"Request {i} should have warning header in log-only mode"
);
}
Ok(())
}
#[tokio::test]
async fn test_rate_limit_backwards_compat_enforce() -> Result<()> {
// When log_only=false and ratio=0, should hard-block at enforce capacity with no warn tier
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(false);
config.flags_warn_capacity_ratio = 0.0; // disable warn tier
config.flags_bucket_capacity = 2;
config.flags_bucket_replenish_rate = 0.1;
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// First 2 requests allowed
for i in 1..=2 {
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"Request {i} should succeed"
);
}
// 3rd request blocked
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::TOO_MANY_REQUESTS,
"Request 3 should be blocked in backwards-compat enforce mode"
);
Ok(())
}
#[tokio::test]
async fn test_rate_limit_per_team_override() -> Result<()> {
let mut config = Config::default_test_config();
config.flags_rate_limit_enabled = FlexBool(true);
config.flags_rate_limit_log_only = FlexBool(false);
config.flags_warn_capacity_ratio = 0.0; // disable warn tier, rely on per-token override
config.flags_bucket_capacity = 100; // high default
config.flags_bucket_replenish_rate = 0.1;
// Set up team with a known token
let redis_client = setup_redis_client(Some(config.redis_url.clone())).await;
let team = insert_new_team_in_redis(redis_client.clone())
.await
.unwrap();
let token = team.api_token.clone();
// Configure a very restrictive custom rate for this specific token
let mut custom_rates = HashMap::new();
custom_rates.insert(token.clone(), "1/hour".to_string());
config.flags_token_rate_limit_overrides =
feature_flags::config::FlagsTokenRateLimitOverrides(custom_rates);
let context = TestContext::new(None).await;
context.insert_new_team(Some(team.id)).await.unwrap();
context
.insert_person(team.id, "user123".to_string(), None)
.await
.unwrap();
let remote_config = json!({
"supportedCompression": ["gzip", "gzip-js"],
"config": {}
});
insert_config_in_hypercache(redis_client.clone(), &token, remote_config).await?;
let server = ServerHandle::for_config(config).await;
let client = reqwest::Client::new();
let payload = json!({
"token": token,
"distinct_id": "user123",
});
// First request succeeds (custom rate: 1/hour, so 1 burst with no replenishment during test)
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::OK,
"First request should succeed"
);
// Second request should be rate limited by the custom per-token rate
let response = client
.post(format!("http://{}/flags", server.addr))
.header("content-type", "application/json")
.json(&payload)
.send()
.await?;
assert_eq!(
response.status(),
StatusCode::TOO_MANY_REQUESTS,
"Second request should be blocked by per-token custom rate"
);
Ok(())
}