oai-statsig-python-core 0.25.0rc2__tar.gz → 0.25.0rc4__tar.gz

{oai_statsig_python_core-0.25.0rc2 → oai_statsig_python_core-0.25.0rc4}/Cargo.lock

@@ -1722,7 +1722,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-grpc"
-version = "0.25.0-rc.2"
+version = "0.25.0-rc.4"
 dependencies = [
  "async-trait",
  "chrono",
@@ -1737,7 +1737,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-rust"
-version = "0.25.0-rc.2"
+version = "0.25.0-rc.4"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3011,7 +3011,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.25.0-rc.2"
+version = "0.25.0-rc.4"
 dependencies = [
  "async-trait",
  "napi",
@@ -3026,7 +3026,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.25.0-rc.2"
+version = "0.25.0-rc.4"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -3041,7 +3041,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.25.0-rc.2"
+version = "0.25.0-rc.4"
 dependencies = [
  "async-trait",
  "oai-statsig-rust",
@@ -3054,7 +3054,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.25.0-rc.2"
+version = "0.25.0-rc.4"
 dependencies = [
  "async-trait",
  "cbindgen",

{oai_statsig_python_core-0.25.0rc2 → oai_statsig_python_core-0.25.0rc4}/Cargo.toml

@@ -15,7 +15,6 @@ strip = "none"
 members = ["statsig-rust", "statsig-grpc", "statsig-pyo3"]
 resolver = "2"
 exclude = [
-    "photon_rust",
     "examples/rust/sample-usage",
     "examples/rust/perf-monitor",
     "examples/rust/mem-bench",
@@ -27,7 +26,7 @@ exclude = [
 [workspace.package]
 edition = "2021"
 license = "ISC"
-version = "0.25.0-rc.2"
+version = "0.25.0-rc.4"
 homepage = "https://statsig.com/"
 authors = ["Statsig", "Daniel Loomb <daniel@statsig.com>"]
 readme = "README.md"

{oai_statsig_python_core-0.25.0rc2 → oai_statsig_python_core-0.25.0rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oai_statsig_python_core
-Version: 0.25.0rc2
+Version: 0.25.0rc4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{oai_statsig_python_core-0.25.0rc2 → oai_statsig_python_core-0.25.0rc4}/statsig-rust/Cargo.toml

@@ -43,7 +43,7 @@ serde_json = { version = "1.0.143", features = [
 ] }
 serde_with = "3.4.0"
 sha2 = "0.10.8"
-oai-statsig-grpc = { path = "../statsig-grpc", version = "0.25.0-rc.2", optional = true }
+oai-statsig-grpc = { path = "../statsig-grpc", version = "0.25.0-rc.4", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{oai_statsig_python_core-0.25.0rc2 → oai_statsig_python_core-0.25.0rc4}/statsig-rust/src/evaluation/evaluator_result.rs

@@ -28,6 +28,8 @@ use crate::statsig_types_raw::{
 use crate::user::StatsigUserInternal;
 use crate::{EvaluationDetails, LayerEvaluationOptions};
 
+const LAUNCHED_GROUP_RULE_ID: &str = "launchedGroup";
+
 #[derive(Default, Debug)]
 pub struct EvaluatorResult {
     pub name: Option<InternedString>,
@@ -54,6 +56,14 @@ pub struct EvaluatorResult {
     pub parameter_rule_ids: Option<HashMap<InternedString, InternedString>>,
 }
 
+fn get_is_user_in_experiment(result: &EvaluatorResult) -> bool {
+    result.is_experiment_group
+        && result
+            .rule_id
+            .as_ref()
+            .is_none_or(|rule_id| rule_id.as_str() != LAUNCHED_GROUP_RULE_ID)
+}
+
 pub fn result_to_gate_raw<'a>(
     gate_name: &'a str,
     eval_details: &'a EvaluationDetails,
@@ -163,7 +173,7 @@ pub fn result_to_experiment_eval(
 
     if spec_entity.is_none_or(|s| s == "experiment") {
         is_experiment_active = Some(result.is_experiment_active);
-        is_user_in_experiment = Some(result.is_experiment_group);
+        is_user_in_experiment = Some(get_is_user_in_experiment(result));
     }
 
     ExperimentEvaluation {
@@ -196,7 +206,7 @@ pub fn result_to_experiment_eval_v2(
     if let Some(spec_entity) = spec_entity {
         if spec_entity == "experiment" {
             is_experiment_active = Some(result.is_experiment_active);
-            is_user_in_experiment = Some(result.is_experiment_group);
+            is_user_in_experiment = Some(get_is_user_in_experiment(result));
         }
     }
 
@@ -232,7 +242,7 @@ pub fn result_to_experiment_eval_init_v2(
     if let Some(spec_entity) = spec_entity {
         if spec_entity == "experiment" {
             is_experiment_active = Some(result.is_experiment_active);
-            is_user_in_experiment = Some(result.is_experiment_group);
+            is_user_in_experiment = Some(get_is_user_in_experiment(result));
         }
     }
 
@@ -308,7 +318,7 @@ pub fn result_to_layer_eval(layer_name: &str, result: &mut EvaluatorResult) -> L
         if !config_delegate.is_empty() {
             allocated_experiment_name = Some(config_delegate.clone());
             is_experiment_active = Some(result.is_experiment_active);
-            is_user_in_experiment = Some(result.is_experiment_group);
+            is_user_in_experiment = Some(get_is_user_in_experiment(result));
         }
     }
 
@@ -358,7 +368,7 @@ pub fn result_to_layer_eval_v2(
         if !config_delegate.is_empty() {
             allocated_experiment_name = Some(config_delegate.clone());
             is_experiment_active = Some(result.is_experiment_active);
-            is_user_in_experiment = Some(result.is_experiment_group);
+            is_user_in_experiment = Some(get_is_user_in_experiment(result));
         }
     }
 
@@ -395,7 +405,7 @@ pub fn result_to_layer_eval_init_v2(
         if !config_delegate.is_empty() {
             allocated_experiment_name = Some(config_delegate.clone());
             is_experiment_active = Some(result.is_experiment_active);
-            is_user_in_experiment = Some(result.is_experiment_group);
+            is_user_in_experiment = Some(get_is_user_in_experiment(result));
         }
     }
 

{oai_statsig_python_core-0.25.0rc2 → oai_statsig_python_core-0.25.0rc4}/statsig-rust/src/gcir/gcir_process_iter.rs

@@ -23,6 +23,7 @@ pub(crate) fn gcir_process_iter<T: GCIRHashable>(
 ) -> Result<HashMap<String, T>, StatsigErr> {
     let mut results = HashMap::new();
     let mut hashes = Vec::new();
+    let pipeline_override_names = get_pipeline_override_names(context);
     let mut keys = specs_map.keys().cloned().collect::<Vec<_>>();
     if options.previous_response_hash.is_some() {
         keys.sort_by(|a, b| a.as_str().cmp(b.as_str()));
@@ -37,6 +38,10 @@ pub(crate) fn gcir_process_iter<T: GCIRHashable>(
             continue;
         }
 
+        if pipeline_override_names.contains(&name) {
+            continue;
+        }
+
         if should_filter_entity(spec, name.as_str(), options) {
             continue;
         }
@@ -91,6 +96,28 @@ pub(crate) fn gcir_process_iter<T: GCIRHashable>(
     Ok(results)
 }
 
+fn get_pipeline_override_names(context: &EvaluatorContext) -> HashSet<InternedString> {
+    context
+        .specs_data
+        .overrides
+        .as_ref()
+        .map(get_pipeline_override_names_from_mappings)
+        .unwrap_or_default()
+}
+
+fn get_pipeline_override_names_from_mappings(
+    overrides: &HashMap<String, Vec<crate::specs_response::spec_types::ConfigMapping>>,
+) -> HashSet<InternedString> {
+    overrides
+        .values()
+        .flat_map(|mappings| {
+            mappings
+                .iter()
+                .map(|mapping| mapping.new_config_name.clone())
+        })
+        .collect()
+}
+
 fn should_filter_entity(spec: &Spec, name: &str, options: &ClientInitResponseOptions) -> bool {
     match spec.entity.as_str() {
         "feature_gate" => options
@@ -166,3 +193,28 @@ pub fn hash_secondary_exposures(
         );
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::specs_response::spec_types::{ConfigMapping, OverrideRule};
+
+    #[test]
+    fn filters_only_names_from_pipeline_override_mappings() {
+        let override_names = get_pipeline_override_names_from_mappings(&HashMap::from([(
+            "base_config".to_string(),
+            vec![ConfigMapping {
+                new_config_name: InternedString::from_str_ref("base_config::trigger_id"),
+                rules: vec![OverrideRule {
+                    rule_name: "phase_rule".to_string(),
+                    start_time: Some(0),
+                }],
+            }],
+        )]));
+
+        assert!(override_names.contains(&InternedString::from_str_ref("base_config::trigger_id")));
+        assert!(!override_names.contains(&InternedString::from_str_ref(
+            "manual_config::not_a_pipeline_override"
+        )));
+    }
+}

oai_statsig_python_core-0.25.0rc4/statsig-rust/src/interned_values/__tests__/interned_store_mmap_fetch_tests.rs

@@ -0,0 +1,257 @@
+use crate::{
+    evaluation::rkyv_value::ArchivedRkyvValue,
+    hashing,
+    interned_values::{
+        interned_store::{mmap_path_for_sdk_key, ArchivedMmapDataV1, MmapDataV1},
+        InternedStore,
+    },
+    StatsigErr,
+};
+use memmap2::Mmap;
+#[cfg(unix)]
+use std::os::unix::fs::PermissionsExt;
+#[cfg(target_os = "linux")]
+use std::os::unix::{fs::MetadataExt, process::CommandExt};
+use std::{fs, fs::File, io::Read};
+use wiremock::{
+    matchers::{method, path},
+    Mock, MockServer, ResponseTemplate,
+};
+
+const MMAP_FETCH_SDK_KEY: &str = "interned-store-fetch-mmap";
+const MMAP_REPLACE_SDK_KEY: &str = "interned-store-replace-mmap";
+#[cfg(target_os = "linux")]
+const MMAP_CROSS_UID_SDK_KEY: &str = "interned-store-cross-uid-mmap";
+#[cfg(target_os = "linux")]
+const CROSS_UID_TEST_NAME: &str = "interned_values::__tests__::interned_store_mmap_fetch_tests::uid_10001_can_preload_artifact_written_by_uid_1000";
+const OTHER_MMAP_FETCH_SDK_KEY: &str = "interned-store-fetch-mmap-other";
+const EVAL_PROJ_JSON: &str = include_str!("../../../tests/data/eval_proj_dcs.json");
+const V1_COMPATIBILITY_FIXTURE: &[u8] = include_bytes!("fixtures/interned_store_v1.mmap");
+
+#[test]
+fn v1_compatibility_fixture_remains_readable() {
+    let mut fixture = rkyv::util::AlignedVec::<8>::new();
+    fixture.extend_from_slice(V1_COMPATIBILITY_FIXTURE);
+    let archived = rkyv::access::<ArchivedMmapDataV1, rkyv::rancor::Error>(&fixture).unwrap();
+
+    assert_eq!(archived.format_version(), MmapDataV1::FORMAT_VERSION);
+    assert_eq!(archived.string_for_test(7), Some("v1-string"));
+    assert!(matches!(
+        archived.returnable_for_test(11, "enabled"),
+        Some(ArchivedRkyvValue::Bool(true))
+    ));
+}
+
+#[tokio::test]
+async fn fetch_and_write_mmap_uses_authoritative_sdk_key_path() {
+    let server = MockServer::start().await;
+    Mock::given(method("GET"))
+        .and(path(format!(
+            "/v2/download_config_specs/{MMAP_FETCH_SDK_KEY}.json"
+        )))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .insert_header("content-type", "application/json")
+                .set_body_string(EVAL_PROJ_JSON),
+        )
+        .mount(&server)
+        .await;
+
+    InternedStore::fetch_and_write_mmap_with_specs_url(
+        MMAP_FETCH_SDK_KEY,
+        &format!("{}/v2/download_config_specs", server.uri()),
+    )
+    .await
+    .unwrap();
+
+    let path = mmap_path_for_sdk_key(MMAP_FETCH_SDK_KEY);
+    let expected_filename = format!(
+        "{}_v1_interned_store.mmap",
+        hashing::djb2(MMAP_FETCH_SDK_KEY)
+    );
+    assert!(path.exists());
+    assert_eq!(
+        path.file_name().and_then(|name| name.to_str()),
+        Some(expected_filename.as_str())
+    );
+
+    let file = File::open(&path).unwrap();
+    let mmap = unsafe { Mmap::map(&file).unwrap() };
+    let archived = rkyv::access::<ArchivedMmapDataV1, rkyv::rancor::Error>(&mmap).unwrap();
+    assert_eq!(archived.format_version(), MmapDataV1::FORMAT_VERSION);
+
+    #[cfg(unix)]
+    assert_eq!(
+        fs::metadata(&path).unwrap().permissions().mode() & 0o777,
+        0o644
+    );
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn fetch_and_write_mmap_atomically_replaces_existing_artifact() {
+    let server = MockServer::start().await;
+    Mock::given(method("GET"))
+        .and(path(format!(
+            "/v2/download_config_specs/{MMAP_REPLACE_SDK_KEY}.json"
+        )))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .insert_header("content-type", "application/json")
+                .set_body_string(EVAL_PROJ_JSON),
+        )
+        .mount(&server)
+        .await;
+
+    let path = mmap_path_for_sdk_key(MMAP_REPLACE_SDK_KEY);
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(&path, b"previous artifact").unwrap();
+    let mut previous_artifact = File::open(&path).unwrap();
+
+    InternedStore::fetch_and_write_mmap_with_specs_url(
+        MMAP_REPLACE_SDK_KEY,
+        &format!("{}/v2/download_config_specs", server.uri()),
+    )
+    .await
+    .unwrap();
+
+    let mut previous_contents = Vec::new();
+    previous_artifact
+        .read_to_end(&mut previous_contents)
+        .unwrap();
+    assert_eq!(previous_contents, b"previous artifact");
+
+    let published = fs::read(&path).unwrap();
+    assert_ne!(published, b"previous artifact");
+    rkyv::access::<ArchivedMmapDataV1, rkyv::rancor::Error>(&published).unwrap();
+    assert_eq!(
+        fs::metadata(path).unwrap().permissions().mode() & 0o777,
+        0o644
+    );
+}
+
+#[cfg(target_os = "linux")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+#[ignore = "requires root to run writer and reader subprocesses with distinct UIDs"]
+async fn uid_10001_can_preload_artifact_written_by_uid_1000() {
+    match std::env::var("STATSIG_CROSS_UID_ROLE").as_deref() {
+        Ok("writer") => {
+            InternedStore::fetch_and_write_mmap_with_specs_url(
+                MMAP_CROSS_UID_SDK_KEY,
+                &std::env::var("STATSIG_CROSS_UID_SPECS_URL").unwrap(),
+            )
+            .await
+            .unwrap();
+            return;
+        }
+        Ok("reader") => {
+            InternedStore::preload_mmap(MMAP_CROSS_UID_SDK_KEY).unwrap();
+            return;
+        }
+        Ok(role) => panic!("unexpected cross-UID test role {role}"),
+        Err(_) => {}
+    }
+
+    assert_eq!(
+        unsafe { libc::geteuid() },
+        0,
+        "cross-UID integration test must run as root"
+    );
+
+    let shared_mount = tempfile::tempdir().unwrap();
+    fs::set_permissions(shared_mount.path(), fs::Permissions::from_mode(0o755)).unwrap();
+    let mount_path_bytes = std::os::unix::ffi::OsStrExt::as_bytes(shared_mount.path().as_os_str());
+    let mount_path_c_string = std::ffi::CString::new(mount_path_bytes).unwrap();
+    assert_eq!(
+        unsafe { libc::chown(mount_path_c_string.as_ptr(), 1000, 1000) },
+        0
+    );
+
+    let cross_uid_test_binary = shared_mount.path().join("cross_uid_test");
+    fs::copy(std::env::current_exe().unwrap(), &cross_uid_test_binary).unwrap();
+    fs::set_permissions(&cross_uid_test_binary, fs::Permissions::from_mode(0o755)).unwrap();
+
+    let server = MockServer::start().await;
+    Mock::given(method("GET"))
+        .and(path(format!(
+            "/v2/download_config_specs/{MMAP_CROSS_UID_SDK_KEY}.json"
+        )))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .insert_header("content-type", "application/json")
+                .set_body_string(EVAL_PROJ_JSON),
+        )
+        .mount(&server)
+        .await;
+
+    let run_as = |role: &str, uid: u32| {
+        std::process::Command::new(&cross_uid_test_binary)
+            .arg("--ignored")
+            .arg("--exact")
+            .arg(CROSS_UID_TEST_NAME)
+            .arg("--nocapture")
+            .env("STATSIG_CROSS_UID_ROLE", role)
+            .env(
+                "STATSIG_CROSS_UID_SPECS_URL",
+                format!("{}/v2/download_config_specs", server.uri()),
+            )
+            .env("TMPDIR", shared_mount.path())
+            .uid(uid)
+            .gid(uid)
+            .status()
+            .unwrap()
+    };
+
+    assert!(run_as("writer", 1000).success());
+
+    let artifact_path = shared_mount
+        .path()
+        .join("statsig-interned-store")
+        .join(format!(
+            "{}_v1_interned_store.mmap",
+            hashing::djb2(MMAP_CROSS_UID_SDK_KEY)
+        ));
+    let metadata = fs::metadata(&artifact_path).unwrap();
+    assert_eq!(metadata.uid(), 1000);
+    assert_eq!(metadata.permissions().mode() & 0o777, 0o644);
+
+    assert!(run_as("reader", 10001).success());
+}
+
+#[test]
+fn mmap_paths_are_scoped_by_sdk_key() {
+    assert_ne!(
+        mmap_path_for_sdk_key(MMAP_FETCH_SDK_KEY),
+        mmap_path_for_sdk_key(OTHER_MMAP_FETCH_SDK_KEY)
+    );
+}
+
+#[test]
+fn preload_mmap_rejects_malformed_archive() {
+    let sdk_key = "interned-store-malformed-mmap";
+    let path = mmap_path_for_sdk_key(sdk_key);
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(&path, b"not an rkyv archive").unwrap();
+
+    assert!(matches!(
+        InternedStore::preload_mmap(sdk_key),
+        Err(StatsigErr::SerializationError(_))
+    ));
+}
+
+#[test]
+fn preload_mmap_rejects_unsupported_format_version() {
+    let sdk_key = "interned-store-unsupported-version-mmap";
+    let path = mmap_path_for_sdk_key(sdk_key);
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+
+    let mmap_data = MmapDataV1::empty_with_format_version(2);
+    let archived = rkyv::to_bytes::<rkyv::rancor::Error>(&mmap_data).unwrap();
+    fs::write(&path, archived).unwrap();
+
+    assert!(matches!(
+        InternedStore::preload_mmap(sdk_key),
+        Err(StatsigErr::SerializationError(message))
+            if message == "Unsupported interned mmap format version 2; expected 1"
+    ));
+}

{oai_statsig_python_core-0.25.0rc2 → oai_statsig_python_core-0.25.0rc4}/statsig-rust/src/interned_values/interned_store.rs

@@ -8,6 +8,9 @@ use std::{
     time::{Duration, Instant},
 };
 
+#[cfg(unix)]
+use std::os::unix::fs::PermissionsExt;
+
 use ahash::AHashMap;
 use lazy_static::lazy_static;
 use memmap2::Mmap;
@@ -176,6 +179,10 @@ impl InternedStore {
         Ok(())
     }
 
+    /// Publishes an mmap artifact selected by `sdk_key`.
+    ///
+    /// On Unix, the finalized artifact is atomically published with mode `0644`
+    /// so readers with unrelated UIDs can consume a read-only shared mount.
     pub async fn fetch_and_write_mmap(sdk_key: &str) -> Result<(), StatsigErr> {
         Self::fetch_and_write_mmap_with_options(sdk_key, None).await
     }
@@ -231,6 +238,10 @@ fn write_mmap_specs(
 
     file.write_all(&archived)
         .map_err(|e| StatsigErr::FileError(e.to_string()))?;
+    #[cfg(unix)]
+    file.as_file()
+        .set_permissions(std::fs::Permissions::from_mode(0o644))
+        .map_err(|e| StatsigErr::FileError(e.to_string()))?;
     file.as_file()
         .sync_all()
         .map_err(|e| StatsigErr::FileError(e.to_string()))?;

{oai_statsig_python_core-0.25.0rc2 → oai_statsig_python_core-0.25.0rc4}/statsig-rust/tests/gcir_tests.rs

@@ -119,6 +119,88 @@ fn eval_proj_dcs_with_nullable_versions() -> String {
     serde_json::to_string(&json).expect("Unable to serialize fixture")
 }
 
+fn eval_proj_dcs_with_launched_group_marked_experiment_group() -> String {
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("tests/data/eval_proj_dcs.json");
+
+    let data = fs::read_to_string(path).expect("Unable to read fixture");
+    let mut json: Value = serde_json::from_str(&data).expect("Unable to parse fixture");
+
+    json.get_mut("dynamic_configs")
+        .unwrap()
+        .get_mut("test_decision_made")
+        .unwrap()
+        .get_mut("rules")
+        .unwrap()
+        .as_array_mut()
+        .unwrap()[0]
+        .as_object_mut()
+        .unwrap()
+        .insert("isExperimentGroup".to_string(), json!(true));
+
+    serde_json::to_string(&json).expect("Unable to serialize fixture")
+}
+
+fn eval_proj_dcs_with_pipeline_override() -> String {
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("tests/data/eval_proj_dcs.json");
+
+    let data = fs::read_to_string(path).expect("Unable to read fixture");
+    let mut json: Value = serde_json::from_str(&data).expect("Unable to parse fixture");
+
+    let synthetic_name = "test_custom_config::pipeline_trigger";
+    let mut synthetic_config = json
+        .get("dynamic_configs")
+        .unwrap()
+        .get("test_custom_config")
+        .unwrap()
+        .clone();
+    synthetic_config["defaultValue"] = json!({
+        "header_text": "pipeline override"
+    });
+    synthetic_config["rules"] = json!([]);
+    synthetic_config["version"] = json!(999);
+
+    json.get_mut("dynamic_configs")
+        .unwrap()
+        .as_object_mut()
+        .unwrap()
+        .insert(synthetic_name.to_string(), synthetic_config);
+
+    json.as_object_mut().unwrap().insert(
+        "override_rules".to_string(),
+        json!({
+            "statsig::everyone": {
+                "name": "statsig::everyone",
+                "passPercentage": 100,
+                "conditions": ["1828919350"],
+                "returnValue": true,
+                "id": "statsig::everyone",
+                "salt": "statsig::everyone",
+                "idType": "userID"
+            }
+        }),
+    );
+    json.as_object_mut().unwrap().insert(
+        "overrides".to_string(),
+        json!({
+            "test_custom_config": [
+                {
+                    "new_config_name": synthetic_name,
+                    "rules": [
+                        {
+                            "rule_name": "statsig::everyone",
+                            "start_time": 0
+                        }
+                    ]
+                }
+            ]
+        }),
+    );
+
+    serde_json::to_string(&json).expect("Unable to serialize fixture")
+}
+
 #[tokio::test]
 async fn test_feature_gate_filter() {
     let response_options = ClientInitResponseOptions {
@@ -171,6 +253,48 @@ async fn test_nullable_config_versions() {
     assert!(layer.get("version").unwrap().is_null());
 }
 
+#[tokio::test]
+async fn test_launched_group_is_not_user_in_experiment() {
+    let json_obj = setup_with_specs_data(
+        eval_proj_dcs_with_launched_group_marked_experiment_group(),
+        HashAlgorithm::None,
+    )
+    .await;
+
+    let experiment = json_obj
+        .get("dynamic_configs")
+        .unwrap()
+        .get("test_decision_made")
+        .unwrap();
+
+    assert_eq!(experiment.get("rule_id").unwrap(), "launchedGroup");
+    assert_eq!(experiment.get("is_user_in_experiment").unwrap(), false);
+}
+
+#[tokio::test]
+async fn test_pipeline_override_specs_are_not_returned_in_initialize() {
+    let json_obj =
+        setup_with_specs_data(eval_proj_dcs_with_pipeline_override(), HashAlgorithm::None).await;
+
+    let configs = json_obj
+        .get("dynamic_configs")
+        .unwrap()
+        .as_object()
+        .unwrap();
+    assert!(configs.contains_key("test_custom_config"));
+    assert!(!configs.contains_key("test_custom_config::pipeline_trigger"));
+    assert_json_eq!(
+        configs
+            .get("test_custom_config")
+            .unwrap()
+            .get("value")
+            .unwrap(),
+        &json!({
+            "header_text": "pipeline override"
+        })
+    );
+}
+
 #[tokio::test]
 async fn test_public_gate() {
     let json_obj = setup(HashAlgorithm::None).await;