: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
mod field_mask;
mod mocks;
mod routing;
use std::sync::Arc;
use personhog_proto::personhog::replica::v1::person_hog_replica_server::PersonHogReplica;
use personhog_proto::personhog::types::v1::{
CountCohortMembersRequest, CreateGroupRequest, DeleteCohortMemberRequest,
DeleteCohortMembersBulkRequest, DeleteGroupTypeMappingRequest,
DeleteGroupTypeMappingsBatchForTeamRequest, DeleteGroupsBatchForTeamRequest,
DeletePersonsBatchForTeamRequest, DeletePersonsRequest, DeleteTombstonedPersonsRequest,
EnsurePersonVersionFloorsRequest, GetGroupRequest, GetPersonRequest,
GetPersonsByDistinctIdsInTeamRequest, InsertCohortMembersRequest, ListCohortMemberIdsRequest,
PersonVersionFloor, UpdateGroupRequest, UpdateGroupTypeMappingRequest,
UpsertHashKeyOverridesRequest, VersionBoundedPerson,
};
use rstest::rstest;
use tonic::Request;
use mocks::FailingStorage;
use super::{PersonHogReplicaService, MAX_BATCH_DELETE_SIZE};
#[tokio::test]
async fn test_connection_error_returns_unavailable() {
let storage = Arc::new(FailingStorage::with_connection_error());
let service = PersonHogReplicaService::new(storage);
let result = service
.get_person(Request::new(GetPersonRequest {
team_id: 1,
person_id: 1,
read_options: None,
}))
.await;
let status = result.unwrap_err();
assert_eq!(status.code(), tonic::Code::Unavailable);
assert!(status.message().contains("Database unavailable"));
assert!(status.message().contains("connection refused"));
}
#[tokio::test]
async fn test_pool_exhausted_returns_unavailable() {
let storage = Arc::new(FailingStorage::with_pool_exhausted());
let service = PersonHogReplicaService::new(storage);
let result = service
.get_person(Request::new(GetPersonRequest {
team_id: 1,
person_id: 1,
read_options: None,
}))
.await;
let status = result.unwrap_err();
assert_eq!(status.code(), tonic::Code::Unavailable);
assert!(status.message().contains("pool exhausted"));
}
#[tokio::test]
async fn test_query_error_returns_internal() {
let storage = Arc::new(FailingStorage::with_query_error());
let service = PersonHogReplicaService::new(storage);
let result = service
.get_person(Request::new(GetPersonRequest {
team_id: 1,
person_id: 1,
read_options: None,
}))
.await;
let status = result.unwrap_err();
assert_eq!(status.code(), tonic::Code::Internal);
assert!(status.message().contains("Database error"));
assert!(status.message().contains("syntax error"));
}
#[tokio::test]
async fn test_connection_error_on_batch_operation_returns_unavailable() {
let storage = Arc::new(FailingStorage::with_connection_error());
let service = PersonHogReplicaService::new(storage);
let result = service
.get_persons_by_distinct_ids_in_team(Request::new(GetPersonsByDistinctIdsInTeamRequest {
team_id: 1,
distinct_ids: vec!["user1".to_string(), "user2".to_string()],
read_options: None,
}))
.await;
let status = result.unwrap_err();
assert_eq!(status.code(), tonic::Code::Unavailable);
}
#[tokio::test]
async fn test_query_error_on_group_operation_returns_internal() {
let storage = Arc::new(FailingStorage::with_query_error());
let service = PersonHogReplicaService::new(storage);
let result = service
.get_group(Request::new(GetGroupRequest {
team_id: 1,
group_type_index: 0,
group_key: "test".to_string(),
read_options: None,
}))
.await;
let status = result.unwrap_err();
assert_eq!(status.code(), tonic::Code::Internal);
}
// ============================================================
// DeletePersons tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_delete_persons_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.delete_persons(Request::new(DeletePersonsRequest {
team_id: 1,
person_uuids: vec!["00000000-0000-0000-0000-000000000001".to_string()],
mode: 0,
}))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[rstest]
#[case::too_many_uuids(
(0..1001).map(|i| format!("00000000-0000-0000-0000-{i:012}")).collect(),
"1000"
)]
#[case::invalid_uuid(vec!["not-a-valid-uuid".to_string()], "Invalid UUID")]
#[tokio::test]
async fn test_delete_persons_invalid_input(
#[case] person_uuids: Vec<String>,
#[case] expected_message: &str,
) {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.delete_persons(Request::new(DeletePersonsRequest {
team_id: 1,
person_uuids,
mode: 0,
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains(expected_message));
}
#[tokio::test]
async fn test_delete_persons_empty_uuids_returns_zero() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.delete_persons(Request::new(DeletePersonsRequest {
team_id: 1,
person_uuids: vec![],
mode: 0,
}))
.await;
assert_eq!(result.unwrap().get_ref().deleted_count, 0);
}
#[rstest]
#[case::single_uuid(vec!["00000000-0000-0000-0000-000000000001".to_string()])]
#[case::exactly_1000((0..1000).map(|i| format!("00000000-0000-0000-0000-{i:012}")).collect())]
#[tokio::test]
async fn test_delete_persons_success(#[case] person_uuids: Vec<String>) {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.delete_persons(Request::new(DeletePersonsRequest {
team_id: 1,
person_uuids,
mode: 0,
}))
.await;
assert!(result.is_ok());
}
// ============================================================
// DeleteTombstonedPersons tests
// ============================================================
fn bounded(uuid: &str, max_version: i64) -> VersionBoundedPerson {
VersionBoundedPerson {
person_uuid: uuid.to_string(),
max_version,
}
}
const SOME_UUID: &str = "00000000-0000-0000-0000-000000000001";
#[rstest]
#[case::too_many_uuids(
(0..1001).map(|i| format!("00000000-0000-0000-0000-{i:012}")).collect(),
vec![],
0,
"1000"
)]
#[case::too_many_bounded_persons(
vec![],
(0..1001).map(|i| bounded(&format!("00000000-0000-0000-0000-{i:012}"), 1)).collect(),
0,
"1000"
)]
#[case::invalid_uuid(vec!["not-a-valid-uuid".to_string()], vec![], 0, "Invalid UUID")]
#[case::invalid_bounded_uuid(vec![], vec![bounded("not-a-valid-uuid", 1)], 0, "Invalid UUID")]
#[case::negative_max_rows(vec![SOME_UUID.to_string()], vec![], -1, "max_rows")]
#[case::negative_max_version(vec![], vec![bounded(SOME_UUID, -1)], 0, "max_version")]
#[case::both_uuid_lists(
vec![SOME_UUID.to_string()],
vec![bounded(SOME_UUID, 1)],
0,
"not both"
)]
#[tokio::test]
async fn test_delete_tombstoned_persons_invalid_input(
#[case] person_uuids: Vec<String>,
#[case] bounded_persons: Vec<VersionBoundedPerson>,
#[case] max_rows: i64,
#[case] expected_message: &str,
) {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.delete_tombstoned_persons(Request::new(DeleteTombstonedPersonsRequest {
team_id: 1,
person_uuids,
max_rows,
bounded_persons,
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains(expected_message));
}
// ============================================================
// DeletePersonsBatchForTeam tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::pool_exhausted(FailingStorage::with_pool_exhausted(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_delete_persons_batch_for_team_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.delete_persons_batch_for_team(Request::new(DeletePersonsBatchForTeamRequest {
team_id: 1,
batch_size: 100,
}))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[rstest]
#[case::zero(0)]
#[case::negative(-1)]
#[case::exceeds_max(MAX_BATCH_DELETE_SIZE + 1)]
#[tokio::test]
async fn test_delete_persons_batch_for_team_invalid_batch_size(#[case] batch_size: i64) {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.delete_persons_batch_for_team(Request::new(DeletePersonsBatchForTeamRequest {
team_id: 1,
batch_size,
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("batch_size"));
}
#[tokio::test]
async fn test_delete_persons_batch_for_team_success() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.delete_persons_batch_for_team(Request::new(DeletePersonsBatchForTeamRequest {
team_id: 1,
batch_size: 1000,
}))
.await;
assert!(result.is_ok());
}
// ============================================================
// CountCohortMembers tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_count_cohort_members_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.count_cohort_members(Request::new(CountCohortMembersRequest {
cohort_ids: vec![1],
read_options: None,
}))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[tokio::test]
async fn test_count_cohort_members_empty_cohort_ids_returns_zero() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.count_cohort_members(Request::new(CountCohortMembersRequest {
cohort_ids: vec![],
read_options: None,
}))
.await;
assert_eq!(result.unwrap().get_ref().count, 0);
}
#[tokio::test]
async fn test_count_cohort_members_success() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.count_cohort_members(Request::new(CountCohortMembersRequest {
cohort_ids: vec![1, 2, 3],
read_options: None,
}))
.await;
assert!(result.is_ok());
}
// ============================================================
// DeleteCohortMember tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::pool_exhausted(FailingStorage::with_pool_exhausted(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_delete_cohort_member_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.delete_cohort_member(Request::new(DeleteCohortMemberRequest {
cohort_id: 1,
person_id: 42,
}))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[tokio::test]
async fn test_delete_cohort_member_success() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.delete_cohort_member(Request::new(DeleteCohortMemberRequest {
cohort_id: 1,
person_id: 42,
}))
.await;
let response = result.unwrap().into_inner();
assert!(!response.deleted);
}
// ============================================================
// DeleteCohortMembersBulk tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::pool_exhausted(FailingStorage::with_pool_exhausted(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_delete_cohort_members_bulk_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.delete_cohort_members_bulk(Request::new(DeleteCohortMembersBulkRequest {
cohort_ids: vec![1],
batch_size: 1000,
}))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[rstest]
#[case::zero(0)]
#[case::negative(-1)]
#[case::exceeds_max(10001)]
#[tokio::test]
async fn test_delete_cohort_members_bulk_invalid_batch_size(#[case] batch_size: i32) {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.delete_cohort_members_bulk(Request::new(DeleteCohortMembersBulkRequest {
cohort_ids: vec![1],
batch_size,
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("batch_size"));
}
#[tokio::test]
async fn test_delete_cohort_members_bulk_empty_cohort_ids_returns_zero() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.delete_cohort_members_bulk(Request::new(DeleteCohortMembersBulkRequest {
cohort_ids: vec![],
batch_size: 1000,
}))
.await;
assert_eq!(result.unwrap().get_ref().deleted_count, 0);
}
#[tokio::test]
async fn test_delete_cohort_members_bulk_success() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.delete_cohort_members_bulk(Request::new(DeleteCohortMembersBulkRequest {
cohort_ids: vec![1, 2],
batch_size: 5000,
}))
.await;
assert!(result.is_ok());
}
// ============================================================
// InsertCohortMembers tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::pool_exhausted(FailingStorage::with_pool_exhausted(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_insert_cohort_members_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.insert_cohort_members(Request::new(InsertCohortMembersRequest {
cohort_id: 1,
person_ids: vec![42],
version: None,
}))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[tokio::test]
async fn test_insert_cohort_members_too_many_person_ids() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.insert_cohort_members(Request::new(InsertCohortMembersRequest {
cohort_id: 1,
person_ids: (0..10001).collect(),
version: None,
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("10000"));
}
#[tokio::test]
async fn test_insert_cohort_members_empty_person_ids_returns_zero() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.insert_cohort_members(Request::new(InsertCohortMembersRequest {
cohort_id: 1,
person_ids: vec![],
version: None,
}))
.await;
assert_eq!(result.unwrap().get_ref().inserted_count, 0);
}
#[rstest]
#[case::single_person(vec![42])]
#[case::exactly_10000((0..10000).collect())]
#[tokio::test]
async fn test_insert_cohort_members_success(#[case] person_ids: Vec<i64>) {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let expected_count = person_ids.len() as i64;
let result = service
.insert_cohort_members(Request::new(InsertCohortMembersRequest {
cohort_id: 1,
person_ids,
version: Some(1),
}))
.await;
assert_eq!(result.unwrap().get_ref().inserted_count, expected_count);
}
// ============================================================
// ListCohortMemberIds tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_list_cohort_member_ids_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.list_cohort_member_ids(Request::new(ListCohortMemberIdsRequest {
cohort_id: 1,
cursor: 0,
limit: 100,
read_options: None,
}))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[tokio::test]
async fn test_list_cohort_member_ids_success() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.list_cohort_member_ids(Request::new(ListCohortMemberIdsRequest {
cohort_id: 1,
cursor: 0,
limit: 100,
read_options: None,
}))
.await;
let response = result.unwrap().into_inner();
assert!(response.person_ids.is_empty());
assert_eq!(response.next_cursor, 0);
}
#[tokio::test]
async fn test_list_cohort_member_ids_clamps_invalid_limit() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.list_cohort_member_ids(Request::new(ListCohortMemberIdsRequest {
cohort_id: 1,
cursor: 0,
limit: 0,
read_options: None,
}))
.await;
assert!(result.is_ok());
}
// ============================================================
// CreateGroup tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_create_group_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.create_group(Request::new(CreateGroupRequest {
team_id: 1,
group_type_index: 0,
group_key: "test-key".to_string(),
group_properties: b"{}".to_vec(),
created_at: Some(1000),
}))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[tokio::test]
async fn test_create_group_invalid_timestamp() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.create_group(Request::new(CreateGroupRequest {
team_id: 1,
group_type_index: 0,
group_key: "test-key".to_string(),
group_properties: b"{}".to_vec(),
created_at: Some(i64::MIN),
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("created_at"));
}
#[tokio::test]
async fn test_create_group_invalid_json() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.create_group(Request::new(CreateGroupRequest {
team_id: 1,
group_type_index: 0,
group_key: "test-key".to_string(),
group_properties: b"not json".to_vec(),
created_at: Some(1000),
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("group_properties"));
}
#[tokio::test]
async fn test_create_group_success() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.create_group(Request::new(CreateGroupRequest {
team_id: 1,
group_type_index: 0,
group_key: "test-key".to_string(),
group_properties: b"{}".to_vec(),
created_at: Some(1000),
}))
.await;
let response = result.unwrap().into_inner();
assert!(response.group.is_some());
}
#[tokio::test]
async fn test_create_group_defaults_created_at_to_now() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.create_group(Request::new(CreateGroupRequest {
team_id: 1,
group_type_index: 0,
group_key: "test-key".to_string(),
group_properties: b"{}".to_vec(),
created_at: None,
}))
.await;
let response = result.unwrap().into_inner();
assert!(response.group.is_some());
}
// ============================================================
// UpdateGroup tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_update_group_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.update_group(Request::new(UpdateGroupRequest {
team_id: 1,
group_type_index: 0,
group_key: "test-key".to_string(),
update_mask: vec!["group_properties".to_string()],
group_properties: Some(b"{}".to_vec()),
..Default::default()
}))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[tokio::test]
async fn test_update_group_invalid_json() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.update_group(Request::new(UpdateGroupRequest {
team_id: 1,
group_type_index: 0,
group_key: "test-key".to_string(),
update_mask: vec!["group_properties".to_string()],
group_properties: Some(b"bad".to_vec()),
..Default::default()
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
}
#[tokio::test]
async fn test_update_group_invalid_mask_field() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.update_group(Request::new(UpdateGroupRequest {
team_id: 1,
group_type_index: 0,
group_key: "test-key".to_string(),
update_mask: vec!["nonexistent_field".to_string()],
..Default::default()
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
}
#[tokio::test]
async fn test_update_group_success() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.update_group(Request::new(UpdateGroupRequest {
team_id: 1,
group_type_index: 0,
group_key: "test-key".to_string(),
update_mask: vec!["group_properties".to_string()],
group_properties: Some(b"{}".to_vec()),
..Default::default()
}))
.await;
let response = result.unwrap().into_inner();
assert!(!response.updated);
}
// ============================================================
// DeleteGroupsBatchForTeam tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::pool_exhausted(FailingStorage::with_pool_exhausted(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_delete_groups_batch_for_team_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.delete_groups_batch_for_team(Request::new(DeleteGroupsBatchForTeamRequest {
team_id: 1,
batch_size: 100,
}))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[rstest]
#[case::zero(0)]
#[case::negative(-1)]
#[case::exceeds_max(MAX_BATCH_DELETE_SIZE + 1)]
#[tokio::test]
async fn test_delete_groups_batch_for_team_invalid_batch_size(#[case] batch_size: i64) {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.delete_groups_batch_for_team(Request::new(DeleteGroupsBatchForTeamRequest {
team_id: 1,
batch_size,
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("batch_size"));
}
#[tokio::test]
async fn test_delete_groups_batch_for_team_success() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.delete_groups_batch_for_team(Request::new(DeleteGroupsBatchForTeamRequest {
team_id: 1,
batch_size: 1000,
}))
.await;
assert!(result.is_ok());
}
// ============================================================
// UpdateGroupTypeMapping tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_update_group_type_mapping_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.update_group_type_mapping(Request::new(UpdateGroupTypeMappingRequest {
project_id: 1,
group_type_index: 0,
update_mask: vec!["name_singular".to_string()],
name_singular: Some("Company".to_string()),
name_plural: None,
detail_dashboard_id: None,
default_columns: None,
created_at: None,
}))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[tokio::test]
async fn test_update_group_type_mapping_invalid_mask_field() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.update_group_type_mapping(Request::new(UpdateGroupTypeMappingRequest {
project_id: 1,
group_type_index: 0,
update_mask: vec!["invalid_field".to_string()],
name_singular: None,
name_plural: None,
detail_dashboard_id: None,
default_columns: None,
created_at: None,
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("invalid_field"));
}
#[tokio::test]
async fn test_update_group_type_mapping_accepts_created_at_in_mask() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.update_group_type_mapping(Request::new(UpdateGroupTypeMappingRequest {
project_id: 999,
group_type_index: 0,
update_mask: vec!["created_at".to_string()],
name_singular: None,
name_plural: None,
detail_dashboard_id: None,
default_columns: None,
created_at: Some(1_700_000_000_000),
}))
.await;
// NotFound (from the empty mock) proves the mask passed validation
assert_eq!(result.unwrap_err().code(), tonic::Code::NotFound);
}
#[tokio::test]
async fn test_update_group_type_mapping_invalid_created_at_timestamp() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.update_group_type_mapping(Request::new(UpdateGroupTypeMappingRequest {
project_id: 1,
group_type_index: 0,
update_mask: vec!["created_at".to_string()],
name_singular: None,
name_plural: None,
detail_dashboard_id: None,
default_columns: None,
created_at: Some(i64::MAX),
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("Invalid created_at timestamp"));
}
#[tokio::test]
async fn test_update_group_type_mapping_not_found() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.update_group_type_mapping(Request::new(UpdateGroupTypeMappingRequest {
project_id: 999,
group_type_index: 0,
update_mask: vec!["name_singular".to_string()],
name_singular: Some("Company".to_string()),
name_plural: None,
detail_dashboard_id: None,
default_columns: None,
created_at: None,
}))
.await;
assert_eq!(result.unwrap_err().code(), tonic::Code::NotFound);
}
// ============================================================
// DeleteGroupTypeMapping tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::pool_exhausted(FailingStorage::with_pool_exhausted(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_delete_group_type_mapping_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.delete_group_type_mapping(Request::new(DeleteGroupTypeMappingRequest {
project_id: 1,
group_type_index: 0,
}))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[tokio::test]
async fn test_delete_group_type_mapping_success() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.delete_group_type_mapping(Request::new(DeleteGroupTypeMappingRequest {
project_id: 1,
group_type_index: 0,
}))
.await;
let response = result.unwrap().into_inner();
assert!(!response.deleted);
}
// ============================================================
// DeleteGroupTypeMappingsBatchForTeam tests
// ============================================================
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::pool_exhausted(FailingStorage::with_pool_exhausted(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[tokio::test]
async fn test_delete_group_type_mappings_batch_for_team_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = service
.delete_group_type_mappings_batch_for_team(Request::new(
DeleteGroupTypeMappingsBatchForTeamRequest {
team_id: 1,
batch_size: 100,
},
))
.await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
#[rstest]
#[case::zero(0)]
#[case::negative(-1)]
#[case::exceeds_max(MAX_BATCH_DELETE_SIZE + 1)]
#[tokio::test]
async fn test_delete_group_type_mappings_batch_for_team_invalid_batch_size(
#[case] batch_size: i64,
) {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.delete_group_type_mappings_batch_for_team(Request::new(
DeleteGroupTypeMappingsBatchForTeamRequest {
team_id: 1,
batch_size,
},
))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("batch_size"));
}
#[tokio::test]
async fn test_delete_group_type_mappings_batch_for_team_success() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = service
.delete_group_type_mappings_batch_for_team(Request::new(
DeleteGroupTypeMappingsBatchForTeamRequest {
team_id: 1,
batch_size: 1000,
},
))
.await;
assert!(result.is_ok());
}
// ============================================================
// Version floor tests
// ============================================================
const OWNER_UUID: &str = "00000000-0000-0000-0000-000000000001";
fn uuid_keys(n: usize) -> Vec<String> {
(0..n)
.map(|i| format!("00000000-0000-0000-0000-{i:012}"))
.collect()
}
async fn ensure_person_floors(
service: &PersonHogReplicaService,
keys: Vec<String>,
min_version: i64,
) -> Result<(), tonic::Status> {
service
.ensure_person_version_floors(Request::new(EnsurePersonVersionFloorsRequest {
team_id: 1,
floors: keys
.into_iter()
.map(|person_uuid| PersonVersionFloor {
person_uuid,
min_version,
})
.collect(),
}))
.await
.map(|_| ())
}
#[rstest]
#[case::at_cap(uuid_keys(250), 0, None)]
#[case::over_cap(uuid_keys(251), 0, Some("Maximum 250"))]
#[case::duplicate(vec![OWNER_UUID.to_string(), OWNER_UUID.to_string()], 0, Some("Duplicate key"))]
#[case::duplicate_spelling(vec!["0000000a-0000-0000-0000-00000000000b".to_string(), "0000000A-0000-0000-0000-00000000000B".to_string()], 0, Some("Duplicate key"))]
#[case::negative(uuid_keys(1), -1, Some("must not be negative"))]
#[case::bad_uuid(vec!["nope".to_string()], 0, Some("Invalid UUID"))]
#[tokio::test]
async fn test_ensure_person_version_floors_input_validation(
#[case] keys: Vec<String>,
#[case] min_version: i64,
#[case] expected_error: Option<&str>,
) {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let result = ensure_person_floors(&service, keys, min_version).await;
match expected_error {
None => assert!(result.is_ok(), "{result:?}"),
Some(message) => {
let status = result.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains(message), "{}", status.message());
}
}
}
#[rstest]
#[case::connection_error(FailingStorage::with_connection_error(), tonic::Code::Unavailable)]
#[case::query_error(FailingStorage::with_query_error(), tonic::Code::Internal)]
#[case::lost_race(
FailingStorage::with_failed_precondition(),
tonic::Code::FailedPrecondition
)]
#[tokio::test]
async fn test_ensure_person_version_floors_storage_error(
#[case] storage: FailingStorage,
#[case] expected_code: tonic::Code,
) {
let service = PersonHogReplicaService::new(Arc::new(storage));
let result = ensure_person_floors(&service, uuid_keys(1), 0).await;
assert_eq!(result.unwrap_err().code(), expected_code);
}
// ============================================================
// UpsertHashKeyOverrides tests
// ============================================================
#[tokio::test]
async fn test_upsert_hash_key_overrides_rejects_the_cookieless_sentinel() {
let service = PersonHogReplicaService::new(Arc::new(mocks::SuccessStorage));
let status = service
.upsert_hash_key_overrides(Request::new(UpsertHashKeyOverridesRequest {
team_id: 1,
distinct_ids: vec!["user".to_string()],
hash_key: "$posthog_cookieless".to_string(),
feature_flag_keys: vec!["flag".to_string()],
}))
.await
.unwrap_err();
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("hash_key"));
}