Files
dbx/crates/dbx-sql-data/src/data_grid_extractors/tests.rs
T

1419 lines
56 KiB
Rust

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::<DataGridExtractorOptions>(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::<Value>(&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::<Value>(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::<Value>(&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::<Value>(&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::<Value>(line).expect("valid JSON Lines record"))
.collect::<Vec<_>>();
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::<Value>(&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!("<Ada & Grace>")]];
let html = extract_data_grid_selection(html_request).expect("HTML extraction");
assert!(html.text.contains("&lt;Ada &amp; Grace&gt;"));
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::<DataGridExtractRequest>(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::<DataGridExtractRequest>(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::<DataGridExtractRequest>(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);
}