feat: allow fuzz input override through env var (#7208)

* feat/allow-fuzz-input-override:
 Add environment override for fuzzing parameters and seed values

 - Implement `get_fuzz_override` function to read override values from environment variables for fuzzing parameters.
 - Allow overriding `SEED`, `ACTIONS`, `ROWS`, `TABLES`, `COLUMNS`, `INSERTS`, and `PARTITIONS` in various fuzzing targets.
 - Introduce new constants `GT_FUZZ_INPUT_MAX_PARTITIONS` and `FUZZ_OVERRIDE_PREFIX`.

Signed-off-by: Lei, HUANG <mrsatangel@gmail.com>

* feat/allow-fuzz-input-override: Remove GT_FUZZ_INPUT_MAX_PARTITIONS constant and usage from fuzzing utils and tests

 • Deleted the GT_FUZZ_INPUT_MAX_PARTITIONS constant from fuzzing utility functions.
 • Updated FuzzInput struct in fuzz_migrate_mito_regions.rs to use a hardcoded range instead of get_gt_fuzz_input_max_partitions for determining the number of partitions.

Signed-off-by: Lei, HUANG <mrsatangel@gmail.com>

* feat/allow-fuzz-input-override:
 Improve fuzzing documentation with environment variable overrides

 Enhanced the fuzzing instructions in the README to include guidance on how to override fuzz input using environment variables, providing an example for better clarity.

Signed-off-by: Lei, HUANG <mrsatangel@gmail.com>

---------

Signed-off-by: Lei, HUANG <mrsatangel@gmail.com>

tests-fuzz/README.md

@@ -50,8 +50,19 @@ Print the `std::fmt::Debug` output for an input.
 cargo fuzz fmt fuzz_target .crash --fuzz-dir tests-fuzz -D -s none
 ```
 Rerun the fuzz test with the input.
+You can override fuzz input with environment variables. For example, to override fuzz input like:
+
+```
+FuzzInput {
+    seed: 6666,
+    actions: 175
+}
+```
+
+you can run with `GT_FUZZ_OVERRIDE_SEED=6666` and `GT_FUZZ_OVERRIDE_ACTIONS=175`:
 
 ```bash
-cargo fuzz run fuzz_target .crash --fuzz-dir tests-fuzz -D -s none
+GT_FUZZ_OVERRIDE_SEED=6666 GT_FUZZ_OVERRIDE_ACTIONS=175 cargo fuzz run fuzz_target .crash --fuzz-dir tests-fuzz -D -s none
 ```
+
 For more details, visit [cargo fuzz](https://rust-fuzz.github.io/book/cargo-fuzz/tutorial.html) or run the command `cargo fuzz --help`.

tests-fuzz/src/utils.rs

@@ -125,6 +125,17 @@ pub const GT_FUZZ_INPUT_MAX_TABLES: &str = "GT_FUZZ_INPUT_MAX_TABLES";
 pub const GT_FUZZ_INPUT_MAX_COLUMNS: &str = "GT_FUZZ_INPUT_MAX_COLUMNS";
 pub const GT_FUZZ_INPUT_MAX_ALTER_ACTIONS: &str = "GT_FUZZ_INPUT_MAX_ALTER_ACTIONS";
 pub const GT_FUZZ_INPUT_MAX_INSERT_ACTIONS: &str = "GT_FUZZ_INPUT_MAX_INSERT_ACTIONS";
+pub const FUZZ_OVERRIDE_PREFIX: &str = "GT_FUZZ_OVERRIDE_";
+
+/// Reads an override value for a fuzz parameter from env `GT_FUZZ_OVERRIDE_<NAME>`.
+pub fn get_fuzz_override<T>(name: &str) -> Option<T>
+where
+    T: std::str::FromStr,
+{
+    let _ = dotenv::dotenv();
+    let key = format!("{}{}", FUZZ_OVERRIDE_PREFIX, name.to_ascii_uppercase());
+    env::var(&key).ok().and_then(|v| v.parse().ok())
+}
 
 macro_rules! make_get_from_env_helper {
     ($key:expr, $default: expr) => {

tests-fuzz/targets/ddl/fuzz_alter_logical_table.rs

@@ -44,7 +44,8 @@ use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::alter_expr::AlterTableExprTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::utils::{
-    Connections, get_gt_fuzz_input_max_alter_actions, init_greptime_connections_via_env,
+    Connections, get_fuzz_override, get_gt_fuzz_input_max_alter_actions,
+    init_greptime_connections_via_env,
 };
 use tests_fuzz::validator;
 
@@ -66,10 +67,11 @@ struct FuzzInput {
 
 impl Arbitrary<'_> for FuzzInput {
     fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
-        let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
+        let seed = get_fuzz_override::<u64>("SEED").unwrap_or(u.int_in_range(u64::MIN..=u64::MAX)?);
         let mut rng = ChaChaRng::seed_from_u64(seed);
         let max_actions = get_gt_fuzz_input_max_alter_actions();
-        let actions = rng.random_range(1..max_actions);
+        let actions = get_fuzz_override::<usize>("ACTIONS")
+            .unwrap_or_else(|| rng.random_range(1..max_actions));
 
         Ok(FuzzInput { seed, actions })
     }

tests-fuzz/targets/ddl/fuzz_alter_table.rs

@@ -46,7 +46,8 @@ use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::alter_expr::AlterTableExprTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::utils::{
-    Connections, get_gt_fuzz_input_max_columns, init_greptime_connections_via_env,
+    Connections, get_fuzz_override, get_gt_fuzz_input_max_alter_actions,
+    get_gt_fuzz_input_max_columns, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator;
 struct FuzzContext {
@@ -209,9 +210,11 @@ fn generate_alter_table_expr<R: Rng + 'static>(
 
 impl Arbitrary<'_> for FuzzInput {
     fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
-        let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
+        let seed = get_fuzz_override::<u64>("SEED").unwrap_or(u.int_in_range(u64::MIN..=u64::MAX)?);
         let mut rng = ChaChaRng::seed_from_u64(seed);
-        let actions = rng.random_range(1..256);
+        let max_actions = get_gt_fuzz_input_max_alter_actions();
+        let actions = get_fuzz_override::<usize>("ACTIONS")
+            .unwrap_or_else(|| rng.random_range(1..max_actions));
 
         Ok(FuzzInput { seed, actions })
     }

tests-fuzz/targets/ddl/fuzz_create_database.rs

@@ -31,7 +31,7 @@ use tests_fuzz::generator::create_expr::CreateDatabaseExprGeneratorBuilder;
 use tests_fuzz::ir::CreateDatabaseExpr;
 use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateDatabaseExprTranslator;
-use tests_fuzz::utils::{Connections, init_greptime_connections_via_env};
+use tests_fuzz::utils::{Connections, get_fuzz_override, init_greptime_connections_via_env};
 
 struct FuzzContext {
     greptime: Pool<MySql>,
@@ -50,7 +50,7 @@ struct FuzzInput {
 
 impl Arbitrary<'_> for FuzzInput {
     fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
-        let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
+        let seed = get_fuzz_override::<u64>("SEED").unwrap_or(u.int_in_range(u64::MIN..=u64::MAX)?);
         Ok(FuzzInput { seed })
     }
 }

tests-fuzz/targets/ddl/fuzz_create_logical_table.rs

@@ -38,7 +38,7 @@ use tests_fuzz::generator::create_expr::{
 use tests_fuzz::ir::{Column, primary_key_and_not_null_column_options_generator};
 use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
-use tests_fuzz::utils::{Connections, init_greptime_connections_via_env};
+use tests_fuzz::utils::{Connections, get_fuzz_override, init_greptime_connections_via_env};
 use tests_fuzz::validator;
 
 struct FuzzContext {
@@ -58,7 +58,7 @@ struct FuzzInput {
 
 impl Arbitrary<'_> for FuzzInput {
     fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
-        let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
+        let seed = get_fuzz_override::<u64>("SEED").unwrap_or(u.int_in_range(u64::MIN..=u64::MAX)?);
         Ok(FuzzInput { seed })
     }
 }

tests-fuzz/targets/ddl/fuzz_create_table.rs

@@ -34,7 +34,8 @@ use tests_fuzz::ir::CreateTableExpr;
 use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::utils::{
-    Connections, get_gt_fuzz_input_max_columns, init_greptime_connections_via_env,
+    Connections, get_fuzz_override, get_gt_fuzz_input_max_columns,
+    init_greptime_connections_via_env,
 };
 use tests_fuzz::validator;
 
@@ -56,10 +57,11 @@ struct FuzzInput {
 
 impl Arbitrary<'_> for FuzzInput {
     fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
-        let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
+        let seed = get_fuzz_override::<u64>("SEED").unwrap_or(u.int_in_range(u64::MIN..=u64::MAX)?);
         let mut rng = ChaChaRng::seed_from_u64(seed);
         let max_columns = get_gt_fuzz_input_max_columns();
-        let columns = rng.random_range(2..max_columns);
+        let columns = get_fuzz_override::<usize>("COLUMNS")
+            .unwrap_or_else(|| rng.random_range(2..max_columns));
         Ok(FuzzInput { columns, seed })
     }
 }

tests-fuzz/targets/failover/fuzz_failover_metric_regions.rs

@@ -50,7 +50,8 @@ use tests_fuzz::utils::partition::{
 use tests_fuzz::utils::pod_failure::{inject_datanode_pod_failure, recover_pod_failure};
 use tests_fuzz::utils::{
     Connections, GT_FUZZ_CLUSTER_NAME, GT_FUZZ_CLUSTER_NAMESPACE, compact_table, flush_memtable,
-    get_gt_fuzz_input_max_rows, get_gt_fuzz_input_max_tables, init_greptime_connections_via_env,
+    get_fuzz_override, get_gt_fuzz_input_max_rows, get_gt_fuzz_input_max_tables,
+    init_greptime_connections_via_env,
 };
 use tests_fuzz::validator::row::count_values;
 
@@ -76,12 +77,14 @@ struct FuzzInput {
 
 impl Arbitrary<'_> for FuzzInput {
     fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
-        let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
+        let seed = get_fuzz_override::<u64>("SEED").unwrap_or(u.int_in_range(u64::MIN..=u64::MAX)?);
         let mut rng = ChaChaRng::seed_from_u64(seed);
         let max_rows = get_gt_fuzz_input_max_rows();
-        let rows = rng.random_range(2..max_rows);
+        let rows =
+            get_fuzz_override::<usize>("ROWS").unwrap_or_else(|| rng.random_range(2..max_rows));
         let max_tables = get_gt_fuzz_input_max_tables();
-        let tables = rng.random_range(1..max_tables);
+        let tables =
+            get_fuzz_override::<usize>("TABLES").unwrap_or_else(|| rng.random_range(1..max_tables));
         Ok(FuzzInput { rows, seed, tables })
     }
 }

tests-fuzz/targets/failover/fuzz_failover_mito_regions.rs

@@ -53,7 +53,7 @@ use tests_fuzz::utils::partition::{
 use tests_fuzz::utils::pod_failure::{inject_datanode_pod_failure, recover_pod_failure};
 use tests_fuzz::utils::{
     Connections, GT_FUZZ_CLUSTER_NAME, GT_FUZZ_CLUSTER_NAMESPACE, compact_table, flush_memtable,
-    get_gt_fuzz_input_max_columns, get_gt_fuzz_input_max_insert_actions,
+    get_fuzz_override, get_gt_fuzz_input_max_columns, get_gt_fuzz_input_max_insert_actions,
     get_gt_fuzz_input_max_rows, get_gt_fuzz_input_max_tables, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator::row::count_values;
@@ -83,16 +83,20 @@ struct FuzzInput {
 
 impl Arbitrary<'_> for FuzzInput {
     fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
-        let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
+        let seed = get_fuzz_override::<u64>("SEED").unwrap_or(u.int_in_range(u64::MIN..=u64::MAX)?);
         let mut rng = ChaChaRng::seed_from_u64(seed);
         let max_columns = get_gt_fuzz_input_max_columns();
-        let columns = rng.random_range(2..max_columns);
+        let columns = get_fuzz_override::<usize>("COLUMNS")
+            .unwrap_or_else(|| rng.random_range(2..max_columns));
         let max_rows = get_gt_fuzz_input_max_rows();
-        let rows = rng.random_range(2..max_rows);
+        let rows =
+            get_fuzz_override::<usize>("ROWS").unwrap_or_else(|| rng.random_range(2..max_rows));
         let max_tables = get_gt_fuzz_input_max_tables();
-        let tables = rng.random_range(2..max_tables);
+        let tables =
+            get_fuzz_override::<usize>("TABLES").unwrap_or_else(|| rng.random_range(2..max_tables));
         let max_inserts = get_gt_fuzz_input_max_insert_actions();
-        let inserts = rng.random_range(2..max_inserts);
+        let inserts = get_fuzz_override::<usize>("INSERTS")
+            .unwrap_or_else(|| rng.random_range(2..max_inserts));
         Ok(FuzzInput {
             columns,
             rows,

tests-fuzz/targets/fuzz_insert.rs

@@ -42,8 +42,8 @@ use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::translator::mysql::insert_expr::InsertIntoExprTranslator;
 use tests_fuzz::utils::{
-    Connections, flush_memtable, get_gt_fuzz_input_max_columns, get_gt_fuzz_input_max_rows,
+    Connections, flush_memtable, get_fuzz_override, get_gt_fuzz_input_max_columns,
-    init_greptime_connections_via_env,
+    get_gt_fuzz_input_max_rows, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator;
 
@@ -66,12 +66,14 @@ struct FuzzInput {
 
 impl Arbitrary<'_> for FuzzInput {
     fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
-        let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
+        let seed = get_fuzz_override::<u64>("SEED").unwrap_or(u.int_in_range(u64::MIN..=u64::MAX)?);
         let mut rng = ChaChaRng::seed_from_u64(seed);
         let max_columns = get_gt_fuzz_input_max_columns();
-        let columns = rng.random_range(2..max_columns);
+        let columns = get_fuzz_override::<usize>("COLUMNS")
+            .unwrap_or_else(|| rng.random_range(2..max_columns));
         let max_row = get_gt_fuzz_input_max_rows();
-        let rows = rng.random_range(1..max_row);
+        let rows =
+            get_fuzz_override::<usize>("ROWS").unwrap_or_else(|| rng.random_range(1..max_row));
         Ok(FuzzInput {
             columns,
             rows,

tests-fuzz/targets/fuzz_insert_logical_table.rs

@@ -44,7 +44,7 @@ use tests_fuzz::translator::DslTranslator;
 use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::translator::mysql::insert_expr::InsertIntoExprTranslator;
 use tests_fuzz::utils::{
-    Connections, compact_table, flush_memtable, get_gt_fuzz_input_max_rows,
+    Connections, compact_table, flush_memtable, get_fuzz_override, get_gt_fuzz_input_max_rows,
     get_gt_fuzz_input_max_tables, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator;
@@ -67,12 +67,14 @@ struct FuzzInput {
 
 impl Arbitrary<'_> for FuzzInput {
     fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
-        let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
+        let seed = get_fuzz_override::<u64>("SEED").unwrap_or(u.int_in_range(u64::MIN..=u64::MAX)?);
         let mut rng = ChaChaRng::seed_from_u64(seed);
         let max_tables = get_gt_fuzz_input_max_tables();
-        let tables = rng.random_range(1..max_tables);
+        let tables =
+            get_fuzz_override::<usize>("TABLES").unwrap_or_else(|| rng.random_range(1..max_tables));
         let max_row = get_gt_fuzz_input_max_rows();
-        let rows = rng.random_range(1..max_row);
+        let rows =
+            get_fuzz_override::<usize>("ROWS").unwrap_or_else(|| rng.random_range(1..max_row));
         Ok(FuzzInput { tables, seed, rows })
     }
 }

tests-fuzz/targets/migration/fuzz_migrate_metric_regions.rs

@@ -51,7 +51,7 @@ use tests_fuzz::utils::partition::{fetch_partition, fetch_partitions, region_dis
 use tests_fuzz::utils::procedure::procedure_state;
 use tests_fuzz::utils::wait::wait_condition_fn;
 use tests_fuzz::utils::{
-    Connections, compact_table, flush_memtable, get_gt_fuzz_input_max_rows,
+    Connections, compact_table, flush_memtable, get_fuzz_override, get_gt_fuzz_input_max_rows,
     get_gt_fuzz_input_max_tables, init_greptime_connections_via_env,
 };
 use tests_fuzz::validator::row::count_values;
@@ -75,12 +75,14 @@ struct FuzzInput {
 
 impl Arbitrary<'_> for FuzzInput {
     fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
-        let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
+        let seed = get_fuzz_override::<u64>("SEED").unwrap_or(u.int_in_range(u64::MIN..=u64::MAX)?);
         let mut rng = ChaChaRng::seed_from_u64(seed);
         let max_rows = get_gt_fuzz_input_max_rows();
-        let rows = rng.random_range(2..max_rows);
+        let rows =
+            get_fuzz_override::<usize>("ROWS").unwrap_or_else(|| rng.random_range(2..max_rows));
         let max_tables = get_gt_fuzz_input_max_tables();
-        let tables = rng.random_range(1..max_tables);
+        let tables =
+            get_fuzz_override::<usize>("TABLES").unwrap_or_else(|| rng.random_range(1..max_tables));
 
         Ok(FuzzInput { rows, seed, tables })
     }

tests-fuzz/targets/migration/fuzz_migrate_mito_regions.rs

@@ -50,7 +50,9 @@ use tests_fuzz::utils::partition::{fetch_partition, fetch_partitions, region_dis
 use tests_fuzz::utils::procedure::procedure_state;
 use tests_fuzz::utils::wait::wait_condition_fn;
 use tests_fuzz::utils::{
-    Connections, compact_table, flush_memtable, init_greptime_connections_via_env,
+    Connections, compact_table, flush_memtable, get_fuzz_override, get_gt_fuzz_input_max_columns,
+    get_gt_fuzz_input_max_insert_actions, get_gt_fuzz_input_max_rows,
+    init_greptime_connections_via_env,
 };
 use tests_fuzz::validator;
 
@@ -75,12 +77,19 @@ struct FuzzInput {
 
 impl Arbitrary<'_> for FuzzInput {
     fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
-        let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
+        let seed = get_fuzz_override::<u64>("SEED").unwrap_or(u.int_in_range(u64::MIN..=u64::MAX)?);
         let mut rng = ChaChaRng::seed_from_u64(seed);
-        let partitions = rng.random_range(3..32);
+        let partitions =
-        let columns = rng.random_range(2..30);
+            get_fuzz_override::<usize>("PARTITIONS").unwrap_or_else(|| rng.random_range(3..32));
-        let rows = rng.random_range(128..1024);
+        let max_columns = get_gt_fuzz_input_max_columns();
-        let inserts = rng.random_range(2..8);
+        let columns = get_fuzz_override::<usize>("COLUMNS")
+            .unwrap_or_else(|| rng.random_range(2..max_columns));
+        let max_rows = get_gt_fuzz_input_max_rows();
+        let rows =
+            get_fuzz_override::<usize>("ROWS").unwrap_or_else(|| rng.random_range(128..max_rows));
+        let max_inserts = get_gt_fuzz_input_max_insert_actions();
+        let inserts = get_fuzz_override::<usize>("INSERTS")
+            .unwrap_or_else(|| rng.random_range(2..max_inserts));
         Ok(FuzzInput {
             seed,
             columns,

tests-fuzz/targets/unstable/fuzz_create_table_standalone.rs

@@ -44,7 +44,9 @@ use tests_fuzz::translator::mysql::create_expr::CreateTableExprTranslator;
 use tests_fuzz::utils::config::{get_conf_path, write_config_file};
 use tests_fuzz::utils::health::HttpHealthChecker;
 use tests_fuzz::utils::process::{ProcessManager, ProcessState, UnstableProcessController};
-use tests_fuzz::utils::{get_gt_fuzz_input_max_tables, load_unstable_test_env_variables};
+use tests_fuzz::utils::{
+    get_fuzz_override, get_gt_fuzz_input_max_tables, load_unstable_test_env_variables,
+};
 use tests_fuzz::{error, validator};
 use tokio::sync::watch;
 
@@ -66,10 +68,11 @@ struct FuzzInput {
 
 impl Arbitrary<'_> for FuzzInput {
     fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
-        let seed = u.int_in_range(u64::MIN..=u64::MAX)?;
+        let seed = get_fuzz_override::<u64>("SEED").unwrap_or(u.int_in_range(u64::MIN..=u64::MAX)?);
         let mut rng = ChaChaRng::seed_from_u64(seed);
         let max_tables = get_gt_fuzz_input_max_tables();
-        let tables = rng.random_range(1..max_tables);
+        let tables =
+            get_fuzz_override::<usize>("TABLES").unwrap_or_else(|| rng.random_range(1..max_tables));
         Ok(FuzzInput { seed, tables })
     }
 }