: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 super::*;
use crate::flags::cache_builder::{
compute_flag_dependencies, extract_cohort_ids_from_flag_filters,
};
use crate::flags::feature_flag_list::PreparedFlags;
use crate::flags::flag_models::{
EvaluationMetadata, FeatureFlag, HypercacheFlagsWrapper, PreparedFlagDefinitions,
};
use serde_json::json;
use std::sync::Arc;
fn flag(filters: Value) -> Value {
json!({"id": 1, "team_id": 1, "key": "example", "active": true, "version": 2, "filters": filters})
}
#[test]
fn v1_cache_round_trip_preserves_discriminator_and_unknown_fields() {
for version in [None, Some(json!(1)), Some(json!(1.0))] {
let mut filters = json!({
"groups": [{"aggregation_group_type_index": null, "extra_group": [1],
"properties": [{"key": "email", "type": "person", "value": "example.com", "operator": null, "negation": null, "group_type_index": null, "extra_property": true}]}],
"multivariate": {"extra_options": true, "variants": [{"key": "control", "name": null, "rollout_percentage": 100.0, "extra_variant": [2]}]},
"extra_top": {"nested": [null, false]}
});
if let Some(version) = version {
filters["version"] = version;
}
let decoded: FeatureFlag = serde_json::from_value(flag(filters.clone())).unwrap();
assert!(decoded.filters.is_v1());
assert_eq!(serde_json::to_value(&decoded).unwrap()["filters"], filters);
assert_eq!(decoded.version, Some(2));
}
}
#[test]
fn non_v1_cache_documents_remain_opaque_and_keep_healthy_siblings() {
for version in [
json!(2),
json!(2.0),
json!(3),
json!(1.5),
json!("1"),
json!("2"),
json!(true),
json!(false),
Value::Null,
] {
for groups in [
json!("not v1 groups"),
json!([{"properties": [{"type": "cohort", "key": "id", "value": 42}, {"type": "flag", "key": "999", "value": true}]}]),
] {
let filters = json!({"version": version, "groups": groups, "multivariate": false, "feature_enrollment": "invalid", "opaque": "x".repeat(8192)});
let wrapper: HypercacheFlagsWrapper = serde_json::from_value(json!({
"flags": [flag(filters.clone()), {"id": 2, "team_id": 1, "key": "healthy", "active": true, "filters": {"groups": [{"rollout_percentage": 100}]}}],
"evaluation_metadata": {"dependency_stages": [[1, 2]], "flags_with_missing_deps": [], "transitive_deps": {"1": [], "2": []}}
})).unwrap();
assert!(!wrapper.flags[0].filters.is_v1());
assert_eq!(
serde_json::to_value(&wrapper).unwrap()["flags"][0]["filters"],
filters
);
assert_eq!(wrapper.flags[1].filters.groups.len(), 1);
assert!(extract_cohort_ids_from_flag_filters(&wrapper.flags).is_empty());
let metadata = compute_flag_dependencies(&wrapper.flags).unwrap();
assert_eq!(metadata.dependency_stages, vec![vec![1, 2]]);
assert!(metadata.flags_with_missing_deps.is_empty());
let prepared = PreparedFlagDefinitions {
flags: PreparedFlags::seal(wrapper.flags),
evaluation_metadata: Arc::new(EvaluationMetadata::default()),
cohorts: None,
};
assert!(prepared.estimated_size_bytes() > 8192);
assert!(prepared.flags[0].filters.groups.is_empty());
assert!(prepared.flags[0].filters.require_v1().is_err());
}
}
}
#[test]
fn invalid_v1_filter_documents_keep_ingress_errors() {
use UndecodableDocument::{MalformedV1Groups, NotAnObject, UnreadableV1Object};
for (filters, document) in [
(Value::Null, NotAnObject),
(json!(false), NotAnObject),
(json!(1), NotAnObject),
(json!("filters"), NotAnObject),
(json!([]), NotAnObject),
(json!([2]), NotAnObject),
(json!([1]), NotAnObject),
(json!({"groups": null}), UnreadableV1Object),
(json!({"groups": ""}), UnreadableV1Object),
(json!({"groups": 0}), UnreadableV1Object),
(json!({"groups": {}}), UnreadableV1Object),
(
json!({"groups": [{"properties": false}]}),
UnreadableV1Object,
),
(
json!({"groups": [{"properties": [{"key": "missing-type"}]}]}),
UnreadableV1Object,
),
(json!({"groups": "not a list"}), MalformedV1Groups),
(json!({"groups": {"key": "value"}}), MalformedV1Groups),
(json!({"groups": [1]}), MalformedV1Groups),
(json!({"groups": [{"properties": "x"}]}), MalformedV1Groups),
(json!({"groups": [{"properties": [[]]}]}), MalformedV1Groups),
] {
assert!(serde_json::from_value::<FeatureFlag>(flag(filters.clone())).is_err());
assert_eq!(
decode_filters(filters.clone()).unwrap_err().document,
document,
"{filters}"
);
}
// A number serde cannot represent hides the malformed `groups` from the classifier.
let unrepresentable = format!(r#"{{"groups": "not a list", "x": 1{}}}"#, "0".repeat(400));
assert_eq!(
decode_raw_filters(RawValue::from_string(unrepresentable).unwrap())
.unwrap_err()
.document,
UnreadableV1Object
);
let mut missing = flag(json!({}));
missing.as_object_mut().unwrap().remove("filters");
assert!(serde_json::from_value::<FeatureFlag>(missing).is_err());
let empty: FeatureFlag = serde_json::from_value(flag(json!({}))).unwrap();
assert!(empty.filters.groups.is_empty());
}
#[test]
fn v2_ingress_counts_parse_outcomes_without_configuration_labels() {
use metrics_util::debugging::{DebugValue, DebuggingRecorder};
let recorder = DebuggingRecorder::new();
let valid =
json!({"version": 2, "return_type": "boolean", "default_value": false, "rules": []});
let mut malformed = valid.clone();
malformed["default_value"] = json!("invalid");
let mut unsupported = valid.clone();
unsupported["aggregation_group_type_index"] = json!(0);
let mut oversized = valid.clone();
oversized["extra"] = json!("x".repeat(*config_v2::MAX_CONFIG_BYTES));
metrics::with_local_recorder(&recorder, || {
for document in [
valid,
malformed,
unsupported,
oversized,
json!({}),
json!({"version": 3}),
] {
decode_filters(document).unwrap();
}
});
let outcomes: std::collections::BTreeSet<_> = recorder
.snapshotter()
.snapshot()
.into_vec()
.into_iter()
.filter(|(key, _, _, _)| key.key().name() == FLAG_V2_PARSE_COUNTER)
.map(|(key, _, _, value)| {
assert_eq!(value, DebugValue::Counter(1));
let labels: Vec<_> = key.key().labels().collect();
assert_eq!(labels.len(), 1);
assert_eq!(labels[0].key(), "outcome");
labels[0].value().to_owned()
})
.collect();
assert_eq!(
outcomes,
["success", "malformed", "unsupported", "limit_exceeded"]
.into_iter()
.map(str::to_owned)
.collect()
);
}