use super::*; use crate::data_grid_sql::{DataGridColumnInfo, DataGridTableMeta}; use crate::models::connection::DatabaseType; use serde_json::json; fn column(name: &str, source_index: usize) -> DataGridExtractColumn { DataGridExtractColumn { display_name: name.to_string(), source_name: Some(name.to_string()), source_index } } fn request(extractor: DataGridExtractorId) -> DataGridExtractRequest { DataGridExtractRequest { version: DATA_GRID_EXTRACTOR_CONTRACT_VERSION, extractor, database_type: Some(DatabaseType::Postgres), identifier_quote: None, table_meta: None, columns: vec![column("id", 0), column("name", 1)], selected_column_indexes: vec![0, 1], rows: vec![vec![json!(1), json!("Ada")], vec![json!(2), json!("Grace, Hopper")]], selection_kind: DataGridSelectionKind::Cells, options: DataGridExtractorOptions::default(), } } #[test] fn partially_deserialized_options_use_the_canonical_defaults() { let options = serde_json::from_value::(json!({ "dsv": { "columnSeparator": ";" }, "sql": { "skipGeneratedColumns": false }, "json": {} })) .expect("deserialize partial extractor options"); assert_eq!(options.dsv.column_separator, ";"); assert_eq!(options.dsv.row_separator, "\n"); assert_eq!(options.dsv.null_text, "NULL"); assert_eq!(options.dsv.quote, '"'); assert_eq!(options.dsv.quote_policy, DataGridQuotePolicy::Minimal); assert!(!options.dsv.include_column_header); assert!(!options.dsv.include_row_header); assert!(options.sql.skip_computed_columns); assert!(!options.sql.skip_generated_columns); assert_eq!(options.sql.insert_mode, crate::data_grid_sql::DataGridCopyInsertMode::Merged); assert!(!options.sql.exclude_primary_keys_from_insert); assert!(options.sql.include_database_name); assert!(options.json.pretty); assert!(!options.json.camel_case_field_names); } #[test] fn insert_database_name_option_handles_engine_namespaces() { use crate::data_grid_sql::DataGridCopyInsertMode; use crate::sql_dialect::uses_single_row_insert_statements; for (database_type, catalog, schema, qualified, unqualified) in [ (DatabaseType::Mysql, None, "a`b", "`a``b`.`users`", "`users`"), (DatabaseType::Goldendb, None, "app", "`app`.`users`", "`users`"), (DatabaseType::Doris, Some("internal"), "app", "`app`.`users`", "`users`"), (DatabaseType::StarRocks, None, "app", "`app`.`users`", "`users`"), (DatabaseType::Sqlite, None, "main", "\"main\".\"users\"", "\"users\""), (DatabaseType::Sqlite, None, "attached", "\"attached\".\"users\"", "\"users\""), (DatabaseType::DuckDb, None, "main", "\"main\".\"users\"", "\"users\""), (DatabaseType::Oracle, None, "APP", "\"APP\".\"users\"", "\"users\""), (DatabaseType::Dameng, None, "APP", "\"APP\".\"users\"", "\"users\""), (DatabaseType::Kingbase, None, "audit", "\"audit\".\"users\"", "\"users\""), (DatabaseType::Gaussdb, None, "audit", "\"audit\".\"users\"", "\"users\""), (DatabaseType::OpenGauss, None, "audit", "\"audit\".\"users\"", "\"users\""), (DatabaseType::Db2, None, "APP", "\"APP\".\"users\"", "\"users\""), (DatabaseType::StarRocks, Some("iceberg"), "app", "`iceberg`.`app`.`users`", "`users`"), (DatabaseType::Postgres, None, "audit", "\"audit\".\"users\"", "\"users\""), (DatabaseType::SqlServer, Some("app"), "audit", "[app].[audit].[users]", "[users]"), (DatabaseType::Doris, Some("iceberg"), "app", "`iceberg`.`app`.`users`", "`users`"), ] { for include_database_name in [true, false] { for insert_mode in [DataGridCopyInsertMode::Merged, DataGridCopyInsertMode::RowByRow] { let mut request = request(DataGridExtractorId::SqlInserts); request.database_type = Some(database_type); request.table_meta = Some(DataGridTableMeta { catalog: catalog.map(str::to_owned), database: Some("app".to_owned()), schema: Some(schema.to_owned()), table_name: "users".to_owned(), primary_keys: vec![], columns: None, }); request.options.sql.include_database_name = include_database_name; request.options.sql.insert_mode = insert_mode; // Exercise the same camelCase contract sent by the frontend. let request = serde_json::from_value(serde_json::to_value(request).unwrap()).unwrap(); let result = extract_data_grid_selection(request).unwrap(); let table = if include_database_name { qualified } else { unqualified }; let statements: Vec<_> = result.text.split(";\n").collect(); let expected_statement_count = if insert_mode == DataGridCopyInsertMode::RowByRow || uses_single_row_insert_statements(database_type) { 2 } else { 1 }; assert_eq!(statements.len(), expected_statement_count); for statement in statements { assert!(statement.starts_with(&format!("INSERT INTO {table} (")), "{statement}"); } } } } } #[test] fn insert_database_name_option_uses_database_when_schema_is_absent() { use crate::data_grid_sql::DataGridCopyInsertMode; for database_type in [DatabaseType::Mysql, DatabaseType::Goldendb, DatabaseType::Doris, DatabaseType::StarRocks] { for (database, schema, qualified) in [ (Some("a`b"), None, "`a``b`.`users`"), (Some("app"), Some(""), "`app`.`users`"), (Some("app"), Some(" "), "`app`.`users`"), (Some("app"), Some("other"), "`other`.`users`"), (None, Some("other"), "`other`.`users`"), (None, None, "`users`"), (Some(" "), None, "`users`"), ] { for include_database_name in [true, false] { for insert_mode in [DataGridCopyInsertMode::Merged, DataGridCopyInsertMode::RowByRow] { let mut request = request(DataGridExtractorId::SqlInserts); request.database_type = Some(database_type); request.table_meta = Some(DataGridTableMeta { catalog: None, database: database.map(str::to_owned), schema: schema.map(str::to_owned), table_name: "users".to_owned(), primary_keys: vec![], columns: None, }); request.options.sql.include_database_name = include_database_name; request.options.sql.insert_mode = insert_mode; let request = serde_json::from_value(serde_json::to_value(request).unwrap()).unwrap(); let result = extract_data_grid_selection(request).unwrap(); let table = if include_database_name { qualified } else { "`users`" }; for statement in result.text.split(";\n") { assert!(statement.starts_with(&format!("INSERT INTO {table} (")), "{statement}"); } } } } } } #[test] fn postgres_insert_can_omit_schema_namespace() { for schema in [Some("dbx_dst_ccfebf6b"), None] { for include_database_name in [true, false] { let mut request = request(DataGridExtractorId::SqlInserts); request.database_type = Some(DatabaseType::Postgres); request.table_meta = Some(DataGridTableMeta { catalog: None, database: Some("app".to_owned()), schema: schema.map(str::to_owned), table_name: "users".to_owned(), primary_keys: vec![], columns: None, }); request.options.sql.include_database_name = include_database_name; let result = extract_data_grid_selection(request).unwrap(); let table = if include_database_name && schema.is_some() { r#""dbx_dst_ccfebf6b"."users""# } else { r#""users""# }; assert!(result.text.starts_with(&format!("INSERT INTO {table} (")), "{}", result.text); } } } #[test] fn extracts_csv_with_minimal_standard_quoting() { let result = extract_data_grid_selection(request(DataGridExtractorId::Csv)).expect("CSV extraction"); assert_eq!(result.text, "1,Ada\n2,\"Grace, Hopper\""); } #[test] fn extracts_raw_values_without_escaping_quotes() { let mut request = request(DataGridExtractorId::Raw); request.columns = vec![column("payload", 0)]; request.selected_column_indexes = vec![0]; request.rows = vec![vec![json!(r#"{"msg":"success"}"#)]]; let result = extract_data_grid_selection(request).expect("raw extraction"); assert_eq!(result.text, r#"{"msg":"success"}"#); assert_eq!(result.mime_type, "text/plain"); } #[test] fn tsv_and_pipe_emit_embedded_quotes_verbatim_while_csv_escapes_them() { // Reproduces #10087: a value that is itself wrapped in double quotes (e.g. // MySQL `SELECT CONCAT('"', id, '"')`) must copy out unchanged from the grid's // default multi-cell (TSV) copy, instead of being wrapped and doubled. let quoted = r#""9932b4d2ad1c4ff88b5bfe1690ee1bb8""#; for (extractor, separator) in [(DataGridExtractorId::Tsv, "\t"), (DataGridExtractorId::PipeSeparated, "|")] { let mut request = request(extractor); request.rows = vec![vec![json!(1), json!(quoted)]]; let result = extract_data_grid_selection(request).expect("plain delimited extraction"); assert_eq!(result.text, format!("1{separator}{quoted}"), "extractor {extractor:?} must not escape quotes"); } // CSV is an RFC4180 format, so the same value must still be quoted and doubled. let mut csv = request(DataGridExtractorId::Csv); csv.rows = vec![vec![json!(1), json!(quoted)]]; let csv_result = extract_data_grid_selection(csv).expect("CSV extraction"); assert_eq!(csv_result.text, format!("1,\"{}\"", quoted.replace('"', "\"\""))); } #[test] fn tsv_still_quotes_values_that_would_break_the_row_shape() { // Relaxing the quote-character trigger must not stop quoting on the actual // separator / line breaks, which would otherwise corrupt the TSV structure. let mut request = request(DataGridExtractorId::Tsv); request.rows = vec![vec![json!(1), json!("a\tb\nc")]]; let result = extract_data_grid_selection(request).expect("TSV extraction"); assert_eq!(result.text, "1\t\"a\tb\nc\""); } #[test] fn raw_exports_null_as_an_empty_value() { let mut request = request(DataGridExtractorId::Raw); request.columns = vec![column("name", 0)]; request.selected_column_indexes = vec![0]; request.rows = vec![vec![Value::Null]]; let result = extract_data_grid_selection(request).expect("raw extraction"); assert_eq!(result.text, ""); } #[test] fn raw_rejects_multiple_selected_cells() { let error = extract_data_grid_selection(request(DataGridExtractorId::Raw)).expect_err("raw must reject multiple cells"); assert_eq!(error.code, DataGridExtractErrorCode::InvalidRawSelection); } #[test] fn csv_distinguishes_null_from_null_string() { let mut request = request(DataGridExtractorId::Csv); request.rows = vec![vec![json!(1), Value::Null], vec![json!(2), json!("NULL")]]; let result = extract_data_grid_selection(request).expect("CSV extraction"); // NULL emits the bare sentinel; the literal string "NULL" is force-quoted. assert_eq!(result.text, "1,NULL\n2,\"NULL\""); } #[test] fn csv_keeps_null_unquoted_under_always_quote() { let mut request = request(DataGridExtractorId::Csv); request.rows = vec![vec![json!(1), Value::Null], vec![json!(2), json!("NULL")]]; request.options.dsv.quote_policy = DataGridQuotePolicy::Always; let result = extract_data_grid_selection(request).expect("CSV extraction"); // NULL stays bare even under Always; the string is quoted, so they differ. assert_eq!(result.text, "\"1\",NULL\n\"2\",\"NULL\""); } #[test] fn csv_null_and_sentinel_collapse_under_never_quote() { let mut request = request(DataGridExtractorId::Csv); request.rows = vec![vec![json!(1), Value::Null], vec![json!(2), json!("NULL")]]; request.options.dsv.quote_policy = DataGridQuotePolicy::Never; let result = extract_data_grid_selection(request).expect("CSV extraction"); // Under Never quoting, NULL and the string "NULL" are inherently indistinguishable. assert_eq!(result.text, "1,NULL\n2,NULL"); } #[test] fn csv_empty_null_text_distinguishes_empty_string() { let mut request = request(DataGridExtractorId::Csv); request.rows = vec![vec![json!(1), Value::Null], vec![json!(2), json!("")]]; request.options.dsv.null_text = String::new(); let result = extract_data_grid_selection(request).expect("CSV extraction"); // NULL -> bare empty; the empty string is force-quoted. assert_eq!(result.text, "1,\n2,\"\""); } #[test] fn one_row_distinguishes_null_from_null_string() { let mut request = request(DataGridExtractorId::OneRow); request.rows = vec![vec![json!(1), Value::Null], vec![json!(2), json!("NULL")]]; let result = extract_data_grid_selection(request).expect("one-row extraction"); assert_eq!(result.text, "1,NULL,2,\"NULL\""); } #[test] fn extracts_one_row_as_a_single_csv_record() { let result = extract_data_grid_selection(request(DataGridExtractorId::OneRow)).expect("One-row extraction"); assert_eq!(result.text, "1,Ada,2,\"Grace, Hopper\""); } #[test] fn extracts_all_remaining_text_table_formats() { let cases = [ (DataGridExtractorId::Tsv, "1\tAda\n2\tGrace, Hopper"), (DataGridExtractorId::TsvWithHeaders, "id\tname\n1\tAda\n2\tGrace, Hopper"), (DataGridExtractorId::CsvWithHeaders, "id,name\n1,Ada\n2,\"Grace, Hopper\""), (DataGridExtractorId::PipeSeparated, "1|Ada\n2|Grace, Hopper"), ( DataGridExtractorId::Markdown, "| id | name |\n| --- | --- |\n| 1 | Ada |\n| 2 | Grace, Hopper |", ), ( DataGridExtractorId::Pretty, "+----+---------------+\n| id | name |\n+----+---------------+\n| 1 | Ada |\n| 2 | Grace, Hopper |\n+----+---------------+\n", ), ]; for (extractor, expected) in cases { let result = extract_data_grid_selection(request(extractor)).expect("text table extraction"); assert_eq!(result.text, expected, "unexpected output for {extractor:?}"); assert_eq!(result.row_count, 2); assert_eq!(result.column_count, 2); } } #[test] fn pretty_output_uses_terminal_width_for_cjk_and_emoji() { let mut request = request(DataGridExtractorId::Pretty); request.columns = vec![column("标签", 0), column("name", 1)]; request.rows = vec![vec![json!("中文"), json!("🙂")]]; let result = extract_data_grid_selection(request).expect("Unicode pretty extraction"); assert_eq!( result.text, "+------+------+ | 标签 | name | +------+------+ | 中文 | 🙂 | +------+------+ " ); } #[test] fn one_row_honors_standard_csv_quote_configuration() { let mut request = request(DataGridExtractorId::OneRow); request.options.dsv.quote_policy = DataGridQuotePolicy::Always; request.options.dsv.quote = '\''; let result = extract_data_grid_selection(request).expect("configured One-row extraction"); assert_eq!(result.text, "'1','Ada','2','Grace, Hopper'"); } #[test] fn extracts_multi_column_sql_in_as_row_value_tuples() { let result = extract_data_grid_selection(request(DataGridExtractorId::SqlInList)).expect("SQL IN extraction"); assert_eq!(result.text, "((1, 'Ada'), (2, 'Grace, Hopper'))"); } #[test] fn sql_in_list_deduplicates_single_selected_values() { let mut request = request(DataGridExtractorId::SqlInList); request.selected_column_indexes = vec![0]; request.rows = vec![ vec![json!(1), json!("first")], vec![json!(1), json!("unselected value differs")], vec![json!(2), json!("last")], ]; let result = extract_data_grid_selection(request).expect("SQL IN extraction"); assert_eq!(result.text, "(1, 2)"); } #[test] fn sql_in_list_deduplicates_multi_column_tuples_in_first_seen_order() { let mut request = request(DataGridExtractorId::SqlInList); request.rows = vec![ vec![json!(2), json!("Grace")], vec![json!(1), json!("Ada")], vec![json!(2), json!("Grace")], vec![json!(1), json!("Lovelace")], vec![json!(1), json!("Ada")], ]; let result = extract_data_grid_selection(request).expect("SQL IN extraction"); assert_eq!(result.text, "((2, 'Grace'), (1, 'Ada'), (1, 'Lovelace'))"); } #[test] fn sql_in_list_deduplicates_only_identical_rendered_literals() { let mut request = request(DataGridExtractorId::SqlInList); request.selected_column_indexes = vec![0]; request.rows = vec![ vec![json!(1)], vec![json!("1")], vec![Value::Null], vec![Value::Null], vec![json!("O'Reilly")], vec![json!("O'Reilly")], ]; let result = extract_data_grid_selection(request).expect("SQL IN extraction"); assert_eq!(result.text, "(1, '1', NULL, 'O''Reilly')"); } #[test] fn sql_in_list_honors_kingbase_bit_literals() { let mut request = request(DataGridExtractorId::SqlInList); request.database_type = Some(DatabaseType::Kingbase); request.identifier_quote = Some("`".to_string()); request.columns = vec![column("flag", 0)]; request.selected_column_indexes = vec![0]; request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "flags".to_string(), primary_keys: vec![], columns: Some(vec![DataGridColumnInfo { name: "flag".to_string(), data_type: "pg_catalog.bit(1)".to_string(), is_nullable: true, is_primary_key: false, column_default: None, extra: None, }]), }); request.rows = vec![vec![json!("0")], vec![json!("1")]]; let result = extract_data_grid_selection(request).expect("Kingbase SQL IN extraction"); assert_eq!(result.text, "(b'0', b'1')"); } #[test] fn preserves_duplicate_json_columns_without_overwriting_values() { let mut request = request(DataGridExtractorId::Json); request.columns[1].display_name = "id".to_string(); let result = extract_data_grid_selection(request).expect("JSON extraction"); assert!(result.text.contains("\"id_2\"")); assert_eq!(result.warnings.len(), 1); } #[test] fn avoids_collisions_between_generated_and_existing_json_column_suffixes() { let mut request = request(DataGridExtractorId::Json); request.columns = vec![column("id", 0), column("id", 1), column("id_2", 2)]; request.selected_column_indexes = vec![0, 1, 2]; request.rows = vec![vec![json!(1), json!(2), json!(3)]]; let result = extract_data_grid_selection(request).expect("JSON extraction"); let rows = serde_json::from_str::(&result.text).expect("valid JSON output"); assert_eq!(rows, json!([{"id": 1, "id_3": 2, "id_2": 3}])); assert_eq!(result.warnings.len(), 1); } #[test] fn builds_updates_with_hidden_primary_keys_and_selected_columns() { let mut request = request(DataGridExtractorId::SqlUpdates); request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: Some("public".to_string()), table_name: "users".to_string(), primary_keys: vec!["id".to_string()], columns: Some(vec![ DataGridColumnInfo { name: "id".to_string(), data_type: "int".to_string(), is_nullable: false, is_primary_key: true, column_default: None, extra: None, }, DataGridColumnInfo { name: "name".to_string(), data_type: "varchar".to_string(), is_nullable: false, is_primary_key: false, column_default: None, extra: None, }, ]), }); request.selected_column_indexes = vec![1]; let result = extract_data_grid_selection(request).expect("SQL Updates extraction"); assert_eq!( result.text, "UPDATE \"public\".\"users\" SET \"name\" = 'Ada' WHERE \"id\" = 1;\nUPDATE \"public\".\"users\" SET \"name\" = 'Grace, Hopper' WHERE \"id\" = 2;" ); } #[test] fn sql_copy_honors_kingbase_mysql_compat_connection_identifier_quote() { let table_meta = DataGridTableMeta { catalog: None, database: None, schema: Some("audit-schema".to_string()), table_name: "events".to_string(), primary_keys: vec!["id".to_string()], columns: Some(vec![ DataGridColumnInfo { name: "id".to_string(), data_type: "int".to_string(), is_nullable: false, is_primary_key: true, column_default: None, extra: None, }, DataGridColumnInfo { name: "event_type".to_string(), data_type: "varchar".to_string(), is_nullable: false, is_primary_key: false, column_default: None, extra: None, }, ]), }; let mut insert = request(DataGridExtractorId::SqlInserts); insert.database_type = Some(DatabaseType::Kingbase); insert.identifier_quote = Some("`".to_string()); insert.table_meta = Some(table_meta.clone()); insert.columns = vec![column("id", 0), column("event_type", 1)]; insert.rows = vec![vec![json!(1), json!("login")]]; let insert_result = extract_data_grid_selection(insert).expect("Kingbase SQL INSERT extraction"); assert_eq!(insert_result.text, "INSERT INTO `audit-schema`.`events` (`id`, `event_type`) VALUES (1, 'login');"); let mut updates = request(DataGridExtractorId::SqlUpdates); updates.database_type = Some(DatabaseType::Kingbase); updates.identifier_quote = Some("`".to_string()); updates.table_meta = Some(table_meta); updates.columns = vec![column("id", 0), column("event_type", 1)]; updates.rows = vec![vec![json!(1), json!("logout")]]; let updates_result = extract_data_grid_selection(updates).expect("Kingbase SQL UPDATE extraction"); assert_eq!(updates_result.text, "UPDATE `audit-schema`.`events` SET `event_type` = 'logout' WHERE `id` = 1;"); } #[test] fn sql_update_computed_column_option_matches_the_frontend_capability() { let mut request = request(DataGridExtractorId::SqlUpdates); request.columns[1].display_name = "search_text".to_string(); request.columns[1].source_name = Some("search_text".to_string()); request.selected_column_indexes = vec![1]; request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "users".to_string(), primary_keys: vec!["id".to_string()], columns: Some(vec![ DataGridColumnInfo { name: "id".to_string(), data_type: "int".to_string(), is_nullable: false, is_primary_key: true, column_default: None, extra: None, }, DataGridColumnInfo { name: "search_text".to_string(), data_type: "text".to_string(), is_nullable: true, is_primary_key: false, column_default: None, extra: Some("GENERATED ALWAYS AS".to_string()), }, ]), }); let skipped = extract_data_grid_selection(request.clone()).expect_err("computed UPDATE is skipped by default"); assert_eq!(skipped.code, DataGridExtractErrorCode::NoWritableColumns); request.options.sql.skip_computed_columns = false; let included = extract_data_grid_selection(request).expect("explicit computed UPDATE extraction"); assert!(included.text.contains("SET \"search_text\" =")); } #[test] fn rejects_null_primary_keys_fail_fast() { let mut request = request(DataGridExtractorId::SqlUpdates); request.rows[0][0] = Value::Null; request.selected_column_indexes = vec![1]; request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "users".to_string(), primary_keys: vec!["id".to_string()], columns: None, }); let error = extract_data_grid_selection(request).expect_err("NULL primary key must fail"); assert_eq!(error.code, DataGridExtractErrorCode::NullPrimaryKey); } #[test] fn extracts_custom_dsv_with_headers_nulls_and_standard_escaping() { let mut request = request(DataGridExtractorId::Dsv); request.rows[0][0] = Value::Null; request.rows[0][1] = json!("Ada;Lovelace"); request.options.dsv = DataGridDsvOptions { column_separator: ";".to_string(), include_column_header: true, ..DataGridDsvOptions::default() }; let result = extract_data_grid_selection(request).expect("custom DSV extraction"); assert_eq!(result.text, "id;name\nNULL;\"Ada;Lovelace\"\n2;Grace, Hopper"); } #[test] fn custom_dsv_honors_row_headers_and_quote_policy() { let mut request = request(DataGridExtractorId::Dsv); request.options.dsv = DataGridDsvOptions { column_separator: ";".to_string(), include_row_header: true, quote_policy: DataGridQuotePolicy::Always, ..DataGridDsvOptions::default() }; let result = extract_data_grid_selection(request).expect("configured DSV extraction"); assert_eq!(result.text, "\"1\";\"1\";\"Ada\"\n\"2\";\"2\";\"Grace, Hopper\""); } #[test] fn extracts_json_lines_as_one_object_per_record() { let result = extract_data_grid_selection(request(DataGridExtractorId::JsonLines)).expect("JSON Lines extraction"); assert_eq!(result.text.lines().count(), 2); let first_row = serde_json::from_str::(result.text.lines().next().unwrap_or_default()).expect("first JSON Lines record"); assert_eq!(first_row, json!({"id": 1, "name": "Ada"})); } #[test] fn extracts_compact_json_when_pretty_printing_is_disabled() { let mut request = request(DataGridExtractorId::Json); request.options.json.pretty = false; let result = extract_data_grid_selection(request).expect("compact JSON extraction"); assert_eq!(result.text, "[{\"id\":1,\"name\":\"Ada\"},{\"id\":2,\"name\":\"Grace, Hopper\"}]"); } #[test] fn converts_snake_case_json_field_names_only_when_enabled() { let mut request = request(DataGridExtractorId::Json); request.columns = vec![ column("ID", 0), column("CODE", 1), column("NAME", 2), column("CREATE_TIME", 3), column("user_id", 4), column("ORDER_ITEM_ID", 5), column("alreadyCamel", 6), column("_display__name_", 7), column("naïve_value", 8), ]; request.selected_column_indexes = vec![0, 1, 2, 3, 4, 5, 6, 7, 8]; request.rows = vec![vec![ json!(1), json!("A01"), json!("Ada"), json!("2026-08-16T08:52:23Z"), json!(7), json!(9), json!("kept"), json!("Ada"), json!(true), ]]; let unchanged = extract_data_grid_selection(request.clone()).expect("default JSON extraction"); assert_eq!( serde_json::from_str::(&unchanged.text).expect("valid default JSON"), json!([{ "ID": 1, "CODE": "A01", "NAME": "Ada", "CREATE_TIME": "2026-08-16T08:52:23Z", "user_id": 7, "ORDER_ITEM_ID": 9, "alreadyCamel": "kept", "_display__name_": "Ada", "naïve_value": true }]) ); request.options.json.camel_case_field_names = true; let converted = extract_data_grid_selection(request).expect("camel-case JSON extraction"); assert_eq!( serde_json::from_str::(&converted.text).expect("valid converted JSON"), json!([{ "id": 1, "code": "A01", "name": "Ada", "createTime": "2026-08-16T08:52:23Z", "userId": 7, "orderItemId": 9, "alreadyCamel": "kept", "displayName": "Ada", "naïveValue": true }]) ); } #[test] fn converts_json_lines_names_and_suffixes_post_conversion_collisions() { let mut request = request(DataGridExtractorId::JsonLines); request.columns = vec![column("user_id", 0), column("userId", 1), column("___", 2)]; request.selected_column_indexes = vec![0, 1, 2]; request.rows = vec![vec![json!(1), json!(2), json!(3)], vec![json!(4), json!(5), json!(6)]]; request.options.json.camel_case_field_names = true; let result = extract_data_grid_selection(request).expect("camel-case JSON Lines extraction"); let rows = result .text .lines() .map(|line| serde_json::from_str::(line).expect("valid JSON Lines record")) .collect::>(); assert_eq!( rows, vec![json!({"userId": 1, "userId_2": 2, "___": 3}), json!({"userId": 4, "userId_2": 5, "___": 6})] ); assert_eq!(result.warnings.len(), 1); assert_eq!(result.warnings[0].code, DataGridExtractWarningCode::DuplicateJsonColumnNames); } #[test] fn suffixes_collisions_after_normalizing_uppercase_json_names() { let mut request = request(DataGridExtractorId::Json); request.columns = vec![column("ID", 0), column("id", 1)]; request.selected_column_indexes = vec![0, 1]; request.rows = vec![vec![json!(1), json!(2)]]; request.options.json.camel_case_field_names = true; let result = extract_data_grid_selection(request).expect("normalized JSON extraction"); assert_eq!(serde_json::from_str::(&result.text).expect("valid JSON"), json!([{"id": 1, "id_2": 2}])); assert_eq!(result.warnings.len(), 1); assert_eq!(result.warnings[0].code, DataGridExtractWarningCode::DuplicateJsonColumnNames); } #[test] fn builds_null_safe_where_clause_predicates() { let mut request = request(DataGridExtractorId::WhereClause); request.selected_column_indexes = vec![1]; request.rows = vec![vec![json!(1), Value::Null]]; let result = extract_data_grid_selection(request).expect("WHERE extraction"); assert_eq!(result.text, "\"name\" IS NULL"); } #[test] fn builds_select_for_one_explicit_cell() { let mut request = request(DataGridExtractorId::SqlSelect); request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: Some("public".to_string()), table_name: "users".to_string(), primary_keys: vec!["id".to_string()], columns: None, }); request.selected_column_indexes = vec![1]; request.rows = vec![vec![json!(7), json!("Ada")]]; let result = extract_data_grid_selection(request).expect("SELECT extraction"); assert_eq!(result.text, "SELECT * FROM \"public\".\"users\" WHERE \"name\" = 'Ada';"); } #[test] fn select_row_uses_complete_identity_including_hidden_columns() { let mut request = request(DataGridExtractorId::SqlSelect); request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "users".to_string(), primary_keys: vec!["tenant_id".to_string(), "id".to_string()], columns: None, }); request.columns = vec![column("name", 0), column("id", 1), column("tenant_id", 2)]; request.selected_column_indexes = vec![0]; request.rows = vec![vec![json!("Ada"), json!(7), json!(9)]]; request.selection_kind = DataGridSelectionKind::Rows; let result = extract_data_grid_selection(request).expect("SELECT extraction"); assert_eq!(result.text, "SELECT * FROM \"users\" WHERE \"tenant_id\" = 9 AND \"id\" = 7;"); } #[test] fn select_row_falls_back_to_all_columns_without_usable_identity() { for primary_keys in [Vec::new(), vec!["id".to_string()]] { let mut request = request(DataGridExtractorId::SqlSelect); request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "users".to_string(), primary_keys, columns: None, }); request.rows = vec![vec![Value::Null, json!("Ada")]]; request.selection_kind = DataGridSelectionKind::Rows; let result = extract_data_grid_selection(request).expect("SELECT extraction"); assert_eq!(result.text, "SELECT * FROM \"users\" WHERE \"id\" IS NULL AND \"name\" = 'Ada';"); } } #[test] fn select_cells_joins_multiple_columns_and_rows() { // A genuine multi-cell selection (same-row columns AND'd, multi-row // selections OR'd) is allowed for SELECT and reuses the WHERE predicate // builder, matching "Copy as WHERE clause" for the same selection. let mut request = request(DataGridExtractorId::SqlSelect); request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "users".to_string(), primary_keys: vec!["id".to_string()], columns: None, }); let result = extract_data_grid_selection(request).expect("multi-cell SELECT extraction"); assert_eq!(result.text, "SELECT * FROM \"users\" WHERE (\"id\" = 1 AND \"name\" = 'Ada') OR (\"id\" = 2 AND \"name\" = 'Grace, Hopper');"); } #[test] fn select_rejects_ambiguous_selection_and_missing_target() { let error = extract_data_grid_selection(request(DataGridExtractorId::SqlSelect)) .expect_err("cells without a table must fail"); assert_eq!(error.code, DataGridExtractErrorCode::MissingTableMetadata); let mut request = request(DataGridExtractorId::SqlSelect); request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "users".to_string(), primary_keys: Vec::new(), columns: None, }); request.selection_kind = DataGridSelectionKind::Columns; let error = extract_data_grid_selection(request.clone()).expect_err("column selection must fail"); assert_eq!(error.code, DataGridExtractErrorCode::InvalidSelectSelection); request.selection_kind = DataGridSelectionKind::Rows; let error = extract_data_grid_selection(request).expect_err("multiple selected rows must fail"); assert_eq!(error.code, DataGridExtractErrorCode::InvalidSelectSelection); } #[test] fn where_clause_applies_mysql_json_cast() { // WHERE must reuse the UPDATE predicate builder so MySQL JSON columns get // CAST(... AS JSON) instead of a raw string literal. let mut request = request(DataGridExtractorId::WhereClause); request.database_type = Some(DatabaseType::Mysql); request.selected_column_indexes = vec![1]; request.rows = vec![vec![json!(1), json!("{\"k\":1}")]]; request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "t".to_string(), primary_keys: vec!["id".to_string()], columns: Some(vec![ DataGridColumnInfo { name: "id".to_string(), data_type: "int".to_string(), is_nullable: false, is_primary_key: true, column_default: None, extra: None, }, DataGridColumnInfo { name: "name".to_string(), data_type: "json".to_string(), is_nullable: true, is_primary_key: false, column_default: None, extra: None, }, ]), }); let mut select_request = request.clone(); select_request.extractor = DataGridExtractorId::SqlSelect; let result = extract_data_grid_selection(request).expect("WHERE extraction"); assert!( result.text.contains("CAST(") && result.text.contains(" AS JSON)"), "expected MySQL JSON CAST predicate, got: {}", result.text ); let select_result = extract_data_grid_selection(select_request).expect("SELECT extraction"); assert!( select_result.text.starts_with("SELECT * FROM `t` WHERE ") && select_result.text.contains("CAST(") && select_result.text.contains(" AS JSON)"), "expected MySQL JSON CAST predicate in SELECT, got: {}", select_result.text ); } #[test] fn select_cells_falls_back_to_display_name_like_where_clause() { // SELECT built from a cell selection reuses write_where_clause, so a // missing source_name must fall back to display_name exactly like WHERE // does, instead of erroring — the two must stay in lockstep for the // identical selection. let mut request = request(DataGridExtractorId::SqlSelect); request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "users".to_string(), primary_keys: vec!["id".to_string()], columns: None, }); request.columns = vec![ DataGridExtractColumn { display_name: "id".to_string(), source_name: None, source_index: 0 }, column("name", 1), ]; let mut where_request = request.clone(); where_request.extractor = DataGridExtractorId::WhereClause; let result = extract_data_grid_selection(request).expect("SELECT extraction with missing source_name"); assert_eq!( result.text, "SELECT * FROM \"users\" WHERE (\"id\" = 1 AND \"name\" = 'Ada') OR (\"id\" = 2 AND \"name\" = 'Grace, Hopper');" ); let where_result = extract_data_grid_selection(where_request).expect("WHERE extraction with missing source_name"); assert_eq!(where_result.text, "(\"id\" = 1 AND \"name\" = 'Ada') OR (\"id\" = 2 AND \"name\" = 'Grace, Hopper')"); } #[test] fn where_clause_rejects_unsupported_nosql_databases() { for database_type in [DatabaseType::MongoDb, DatabaseType::Neo4j, DatabaseType::Tdengine] { let mut request = request(DataGridExtractorId::WhereClause); request.database_type = Some(database_type); let error = extract_data_grid_selection(request).expect_err("WHERE must reject NoSQL"); assert_eq!(error.code, DataGridExtractErrorCode::UnsupportedDatabase, "{database_type:?}"); } } #[test] fn build_data_grid_copy_update_statements_returns_empty_for_mongodb() { use crate::data_grid_sql::{build_data_grid_copy_update_statements, DataGridCopyUpdateStatementOptions}; let options = DataGridCopyUpdateStatementOptions { database_type: Some(DatabaseType::MongoDb), identifier_quote: None, table_meta: DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "t".to_string(), primary_keys: vec!["id".to_string()], columns: None, }, columns: vec!["id".to_string()], source_columns: Some(vec![Some("id".to_string())]), rows: vec![vec![json!(1)]], include_database_name: false, }; assert!(build_data_grid_copy_update_statements(options).is_empty()); } #[test] fn format_grid_sql_literal_uses_numeric_bool_for_sqlserver() { use crate::data_grid_sql::format_grid_sql_literal; let column = DataGridColumnInfo { name: "active".to_string(), data_type: "tinyint".to_string(), is_nullable: true, is_primary_key: false, column_default: None, extra: None, }; // SQL Server has no TRUE/FALSE literals; emit 1/0 even for non-BIT columns. assert_eq!(format_grid_sql_literal(&json!(true), Some(DatabaseType::SqlServer), Some(&column)), "1"); assert_eq!(format_grid_sql_literal(&json!(false), Some(DatabaseType::SqlServer), Some(&column)), "0"); // Other dialects still emit TRUE/FALSE for non-bit columns. assert_eq!(format_grid_sql_literal(&json!(true), Some(DatabaseType::Postgres), Some(&column)), "TRUE"); } #[test] fn escapes_html_and_preserves_xml_null_semantics() { let mut html_request = request(DataGridExtractorId::Html); html_request.rows = vec![vec![json!(1), json!("")]]; let html = extract_data_grid_selection(html_request).expect("HTML extraction"); assert!(html.text.contains("<Ada & Grace>")); let mut xml_request = request(DataGridExtractorId::Xml); xml_request.rows = vec![vec![json!(1), Value::Null]]; let xml = extract_data_grid_selection(xml_request).expect("XML extraction"); assert!(xml.text.contains("name=\"name\" null=\"true\"")); } #[test] fn sql_insert_skips_generated_and_computed_columns() { let mut request = request(DataGridExtractorId::SqlInserts); request.columns.push(column("search_text", 2)); request.selected_column_indexes = vec![0, 1, 2]; request.rows = vec![vec![json!(7), json!("Ada"), json!("generated")]]; request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "users".to_string(), primary_keys: vec!["id".to_string()], columns: Some(vec![ DataGridColumnInfo { name: "id".to_string(), data_type: "int".to_string(), is_nullable: false, is_primary_key: true, column_default: None, extra: Some("auto_increment".to_string()), }, DataGridColumnInfo { name: "name".to_string(), data_type: "varchar".to_string(), is_nullable: false, is_primary_key: false, column_default: None, extra: None, }, DataGridColumnInfo { name: "search_text".to_string(), data_type: "text".to_string(), is_nullable: true, is_primary_key: false, column_default: None, extra: Some("GENERATED ALWAYS AS".to_string()), }, ]), }); let mut include_computed_request = request.clone(); include_computed_request.options.sql.skip_computed_columns = false; let mut include_generated_request = request.clone(); include_generated_request.options.sql.skip_generated_columns = false; let result = extract_data_grid_selection(request).expect("SQL INSERT extraction"); assert!(result.text.contains("name")); assert!(!result.text.contains("search_text")); assert!(result.text.contains("(\"id\", \"name\")")); assert_eq!(result.omitted_columns, vec!["search_text"]); let included = extract_data_grid_selection(include_computed_request).expect("SQL INSERT extraction with computed columns"); assert!(included.text.contains("search_text")); assert!(included.omitted_columns.is_empty()); let included = extract_data_grid_selection(include_generated_request).expect("SQL INSERT extraction with generated columns"); assert!(included.text.contains("(\"id\", \"name\")")); assert_eq!(included.omitted_columns, vec!["search_text"]); } #[test] fn sql_insert_keeps_autoincrement_primary_key_by_default() { let mut request = request(DataGridExtractorId::SqlInserts); request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "users".to_string(), primary_keys: vec!["id".to_string()], columns: Some(vec![ DataGridColumnInfo { name: "id".to_string(), data_type: "int".to_string(), is_nullable: false, is_primary_key: true, column_default: None, extra: Some("auto_increment".to_string()), }, DataGridColumnInfo { name: "name".to_string(), data_type: "varchar".to_string(), is_nullable: false, is_primary_key: false, column_default: None, extra: None, }, ]), }); let result = extract_data_grid_selection(request).expect("SQL INSERT extraction"); assert!(result.text.contains("INSERT INTO \"users\" (\"id\", \"name\")")); assert!(result.text.contains("(1, 'Ada')")); assert!(result.omitted_columns.is_empty()); } #[test] fn sql_insert_honors_primary_key_exclusion_and_row_by_row_mode() { let mut request = request(DataGridExtractorId::SqlInserts); request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: Some("public".to_string()), table_name: "users".to_string(), primary_keys: vec!["id".to_string()], columns: Some(vec![ DataGridColumnInfo { name: "id".to_string(), data_type: "bigint".to_string(), is_nullable: false, is_primary_key: true, column_default: None, extra: Some("auto_increment".to_string()), }, DataGridColumnInfo { name: "name".to_string(), data_type: "text".to_string(), is_nullable: false, is_primary_key: false, column_default: None, extra: None, }, ]), }); request.options.sql.exclude_primary_keys_from_insert = true; request.options.sql.insert_mode = crate::data_grid_sql::DataGridCopyInsertMode::RowByRow; let result = extract_data_grid_selection(request).expect("row-by-row SQL INSERT extraction"); assert_eq!( result.text, "INSERT INTO \"public\".\"users\" (\"name\") VALUES ('Ada');\nINSERT INTO \"public\".\"users\" (\"name\") VALUES ('Grace, Hopper');" ); assert_eq!(result.omitted_columns, vec!["id"]); } #[test] fn sql_insert_primary_key_exclusion_omits_postgres_serial_key() { let mut request = request(DataGridExtractorId::SqlInserts); request.database_type = Some(DatabaseType::Postgres); request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: Some("public".to_string()), table_name: "users".to_string(), primary_keys: vec!["id".to_string()], columns: Some(vec![ DataGridColumnInfo { name: "id".to_string(), data_type: "integer".to_string(), is_nullable: false, is_primary_key: true, column_default: None, extra: Some("serial".to_string()), }, DataGridColumnInfo { name: "name".to_string(), data_type: "text".to_string(), is_nullable: false, is_primary_key: false, column_default: None, extra: None, }, ]), }); request.rows = vec![vec![json!(1), json!("Ada")]]; request.options.sql.exclude_primary_keys_from_insert = true; let result = extract_data_grid_selection(request).expect("PostgreSQL SQL INSERT extraction"); assert_eq!(result.text, "INSERT INTO \"public\".\"users\" (\"name\") VALUES ('Ada');"); assert_eq!(result.omitted_columns, vec!["id"]); } #[test] fn sql_insert_primary_key_exclusion_keeps_manual_composite_key_members() { let mut request = request(DataGridExtractorId::SqlInserts); request.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "daily_stats".to_string(), primary_keys: vec!["id".to_string(), "stat_date".to_string()], columns: Some(vec![ DataGridColumnInfo { name: "id".to_string(), data_type: "bigint".to_string(), is_nullable: false, is_primary_key: true, column_default: None, extra: Some("auto_increment".to_string()), }, DataGridColumnInfo { name: "stat_date".to_string(), data_type: "date".to_string(), is_nullable: false, is_primary_key: true, column_default: None, extra: None, }, DataGridColumnInfo { name: "name".to_string(), data_type: "text".to_string(), is_nullable: false, is_primary_key: false, column_default: None, extra: None, }, ]), }); request.columns = vec![column("id", 0), column("stat_date", 1), column("name", 2)]; request.selected_column_indexes = vec![0, 1, 2]; request.rows = vec![vec![json!(1), json!("2026-08-18"), json!("Ada")]]; request.options.sql.exclude_primary_keys_from_insert = true; let result = extract_data_grid_selection(request).expect("SQL INSERT extraction"); assert_eq!(result.text, "INSERT INTO \"daily_stats\" (\"stat_date\", \"name\") VALUES ('2026-08-18', 'Ada');"); assert_eq!(result.omitted_columns, vec!["id"]); } #[test] fn rejects_invalid_dsv_configuration() { let mut request = request(DataGridExtractorId::Dsv); request.options.dsv.column_separator.clear(); let error = extract_data_grid_selection(request).expect_err("empty separator must fail"); assert_eq!(error.code, DataGridExtractErrorCode::InvalidDsvConfiguration); } #[test] fn rejects_ambiguous_or_oversized_dsv_configuration() { let mut overlapping = request(DataGridExtractorId::Dsv); overlapping.options.dsv.column_separator = "|".to_string(); overlapping.options.dsv.row_separator = "||".to_string(); assert_eq!( extract_data_grid_selection(overlapping).expect_err("overlapping separators must fail").code, DataGridExtractErrorCode::InvalidDsvConfiguration ); let mut conflicting_quote = request(DataGridExtractorId::Csv); conflicting_quote.options.dsv.quote = ','; assert_eq!( extract_data_grid_selection(conflicting_quote).expect_err("separator quote must fail").code, DataGridExtractErrorCode::InvalidDsvConfiguration ); let mut oversized = request(DataGridExtractorId::Dsv); oversized.options.dsv.column_separator = "123456789".to_string(); assert_eq!( extract_data_grid_selection(oversized).expect_err("oversized separator must fail").code, DataGridExtractErrorCode::InvalidDsvConfiguration ); } #[test] fn extractor_contract_uses_the_frontend_camel_case_wire_shape() { let request = request(DataGridExtractorId::CsvWithHeaders); let value = serde_json::to_value(&request).expect("serialize extractor request"); assert_eq!(value["extractor"], "csv-with-headers"); assert_eq!(value["databaseType"], "postgres"); assert_eq!(value["selectedColumnIndexes"], json!([0, 1])); assert_eq!(value["selectionKind"], "cells"); assert_eq!(value["options"]["dsv"]["includeColumnHeader"], false); assert_eq!(value["options"]["json"]["camelCaseFieldNames"], false); assert!(value.get("selected_column_indexes").is_none()); let decoded = serde_json::from_value::(value).expect("deserialize extractor request"); assert_eq!(decoded.extractor, DataGridExtractorId::CsvWithHeaders); assert_eq!(decoded.selected_column_indexes, vec![0, 1]); } #[test] fn extractor_contract_requires_an_explicit_version() { let mut value = serde_json::to_value(request(DataGridExtractorId::Csv)).expect("serialize extractor request"); value.as_object_mut().expect("request object").remove("version"); let error = serde_json::from_value::(value).expect_err("missing version must fail"); assert!(error.to_string().contains("version")); } #[test] fn extractor_contract_rejects_unknown_or_misspelled_fields() { let mut value = serde_json::to_value(request(DataGridExtractorId::Csv)).expect("serialize extractor request"); value["options"]["sql"]["skipComputedColumn"] = json!(false); let error = serde_json::from_value::(value).expect_err("unknown option must fail"); assert!(error.to_string().contains("skipComputedColumn")); } #[test] fn rejects_invalid_contract_and_column_mappings_fail_fast() { let mut unsupported = request(DataGridExtractorId::Csv); unsupported.version = 2; assert_eq!( extract_data_grid_selection(unsupported).expect_err("unsupported contract version").code, DataGridExtractErrorCode::UnsupportedVersion ); let mut invalid_column = request(DataGridExtractorId::Csv); invalid_column.selected_column_indexes = vec![99]; assert_eq!( extract_data_grid_selection(invalid_column).expect_err("invalid selected column").code, DataGridExtractErrorCode::InvalidColumnIndex ); let mut duplicate_column = request(DataGridExtractorId::Csv); duplicate_column.selected_column_indexes = vec![0, 0]; assert_eq!( extract_data_grid_selection(duplicate_column).expect_err("duplicate selected column").code, DataGridExtractErrorCode::InvalidColumnIndex ); let mut invalid_mapping = request(DataGridExtractorId::Csv); invalid_mapping.columns[0].source_index = 99; assert_eq!( extract_data_grid_selection(invalid_mapping).expect_err("invalid source mapping").code, DataGridExtractErrorCode::InvalidColumnMapping ); } #[test] fn sql_updates_require_table_primary_key_and_writable_columns() { let missing_table = request(DataGridExtractorId::SqlUpdates); assert_eq!( extract_data_grid_selection(missing_table).expect_err("missing table metadata").code, DataGridExtractErrorCode::MissingTableMetadata ); let mut missing_primary_key = request(DataGridExtractorId::SqlUpdates); missing_primary_key.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "users".to_string(), primary_keys: Vec::new(), columns: None, }); assert_eq!( extract_data_grid_selection(missing_primary_key).expect_err("missing primary key").code, DataGridExtractErrorCode::MissingPrimaryKey ); let mut primary_key_only = request(DataGridExtractorId::SqlUpdates); primary_key_only.selected_column_indexes = vec![0]; primary_key_only.table_meta = Some(DataGridTableMeta { catalog: None, database: None, schema: None, table_name: "users".to_string(), primary_keys: vec!["id".to_string()], columns: None, }); assert_eq!( extract_data_grid_selection(primary_key_only).expect_err("primary-key-only update").code, DataGridExtractErrorCode::NoWritableColumns ); } #[test] fn rejects_requests_that_exceed_the_column_budget() { let mut request = request(DataGridExtractorId::Csv); request.columns = (0..=DATA_GRID_EXTRACTOR_MAX_COLUMNS).map(|index| column(&format!("column_{index}"), index)).collect(); let error = extract_data_grid_selection(request).expect_err("oversized column list must fail"); assert_eq!(error.code, DataGridExtractErrorCode::InputTooLarge); } #[test] fn rejects_requests_that_exceed_the_selected_index_budget() { // columns list is small, but selected_column_indexes is oversized — // the budget must catch it before Vec::with_capacity allocates. let mut request = request(DataGridExtractorId::Csv); request.selected_column_indexes = (0..=DATA_GRID_EXTRACTOR_MAX_COLUMNS).collect(); let error = extract_data_grid_selection(request).expect_err("oversized index list must fail"); assert_eq!(error.code, DataGridExtractErrorCode::InputTooLarge); } #[test] fn bounded_output_stops_before_allocating_past_the_limit() { let mut output = BoundedOutput::new(4); assert_eq!(output.write(b"1234").expect("bounded write"), 4); assert!(output.write(b"5").is_err()); assert!(output.exceeded_limit()); assert_eq!(output.into_bytes(), b"1234"); } #[test] fn rejects_requests_that_exceed_the_row_budget_before_mapping_values() { let mut request = request(DataGridExtractorId::Csv); request.rows = vec![Vec::new(); DATA_GRID_EXTRACTOR_MAX_ROWS + 1]; let error = extract_data_grid_selection(request).expect_err("oversized request must fail"); assert_eq!(error.code, DataGridExtractErrorCode::InputTooLarge); } #[test] fn rejects_estimated_oversized_sql_before_building_the_statement() { let mut request = request(DataGridExtractorId::SqlInserts); request.columns = vec![column("payload", 0)]; request.selected_column_indexes = vec![0]; request.rows = vec![vec![json!("x".repeat(DATA_GRID_EXTRACTOR_MAX_OUTPUT_BYTES / 6 + 1))]]; let error = extract_data_grid_selection(request).expect_err("oversized SQL must fail before allocation"); assert_eq!(error.code, DataGridExtractErrorCode::OutputTooLarge); }